For iOS & Android teams

AI code review that actually speaks Swift and Kotlin. In Slack.

Reviewed. Fixed. Approved. All before your next standup. Built for polyglot product teams who ship mobile alongside the web.

Install in Slack See a real review

Running today in teams shipping Swift, Kotlin, React Native, and Flutter.

Real Swift + Kotlin LSP Lives in Slack — not a new dashboard One-click auto-fix BYOK: your key, your costs
Slack channel showing 11 pull-request reviews posted by different engineers across multiple repositories in a single afternoon
Redacted for privacy. Real thread available on request.
Real usage, real team

One team. One day. Before lunch.

Engineers50in one Slack channel
Reviews11in 3 hours
Repos6touched before lunch

Swift. Kotlin. Ruby. Python. All reviewed in the same Slack channel, by the same tool, with language-specific depth for each. No dashboards. No context switching. No waiting for a senior engineer to free up.

“I built this because I was drowning in reviews across projects I didn’t know well. Now I review half as many manually — and the Swift and Kotlin findings I don’t have to make myself are the ones I’d probably have missed anyway.”
Ashley Russell Founder, CodePulse · reference workspace
Scoped GitHub App You pick which repos it can review. Revoke in one click. We never ask for org-wide access.
Ephemeral clone Every review spins up a fresh container, clones the branch, reviews it, and shuts down. Your code isn’t stored. We don’t train on it.
Git-reversible auto-fix Fixes are plain commits on your branch. If CI breaks or you disagree, git revert undoes it in one line.
How it works

Three steps. No dashboard round-trips.

Reviews lives in Slack — the tool your team already opens first thing every morning.

1

Paste a PR link in Slack

Any channel CodePulse is in. iOS. Android. React Native. Flutter. Kotlin Multiplatform. They all just work.

2

Claude reviews it with real LSP context

Retain cycles in Swift. Coroutine scope leaks in Kotlin. @MainActor violations. Force-unwraps. guard let opportunities. Not generic text analysis — actual language-server depth.

3

Click Fix the issues. Re-review. Ship.

CodePulse opens a commit with the fixes on your branch. Re-reviews the new head. Approves when it's clean. All from Slack.

Actual language understanding

It catches what generic AI review misses.

Every CodePulse review is backed by a real language server for your stack — not a generic transformer guessing from text. Here's what that looks like in Swift and Kotlin.

Swift FeedViewController.swift 
@MainActor final class FeedViewController: UIViewController {
    @Published var items: [Item] = []

    func prefetch() {
        Task.detached {
            let fresh = try await api.load()
            self.items = fresh
        }
    }
}
Critical Actor isolation escape. Task.detached doesn’t inherit @MainActor, so the write to items publishes off the main actor — runtime crash under strict concurrency, UI flicker otherwise. Use Task { } to inherit, or wrap in await MainActor.run.
Kotlin FirebaseAuthRepositoryImpl.kt 
override suspend fun updateDisplayName(name: String): Result<Unit> {
    return try {
        auth.currentUser?.updateProfile(
            UserProfileChangeRequest.Builder()
                .setDisplayName(name).build()
        )?.await()
        Result.success(Unit)
    } catch (e: Exception) { /* … */ }
}
Important Silent failure. A missing currentUser reports success — the display-name write is skipped. Restore explicit AuthError.Unknown.
Swift finds: retain cycles · force-unwraps · @MainActor violations · SwiftUI @State misuse · async/await escapes · UIKit main-thread violations
Kotlin finds: coroutine scope leaks · nullability regressions · suspend/inline misuse · Compose state hoisting · Flow backpressure · Android lifecycle mistakes
Real review, start to finish

Here’s what you actually get.

Not a mock. This is the exact Slack thread from the review referenced above — the engineer pastes a PR link, CodePulse reviews it, finds the Firebase null-user bug, the engineer fixes it, CodePulse re-reviews, approves. 14 minutes, end to end.

Full Slack thread of a CodePulse review: initial review detects a Firebase null-user bug with 1 important finding, engineer clicks Fix issues, CodePulse re-reviews, and approves the updated PR 14 minutes after the first review.
Redacted to remove company, engineer, and repo identifiers. Finding text and review workflow untouched.
Auto-fix loop

Fix. Re-review. Ship.

The review is only the first step. One click and CodePulse opens a commit on your branch with the fixes. One more click to re-review. Ship.

  1. 1
    Click “Fix the issues”CodePulse opens a plain git commit on your branch with the fixes. You review the commit, not the nits.
  2. 2
    Click “Re-review”A fresh review runs against the updated head. CodePulse reports what's still open, if anything.
  3. 3
    Approved in SlackGreen check, merge, ship. The whole loop in one thread — the real review above closed in 14 minutes.

Nothing destructive. Auto-fixes are just commits — CI runs on the new commit, and if anything breaks, git revert <sha> undoes it in one line. No hidden state to untangle.

Install in Slack
Built for technical teams

Why mobile teams start on BYOK.

Bring-your-own-key is our lowest-cost entry point and a first-class tier — not an afterthought. Mobile teams are technical, cost-conscious, and usually already track LLM spend. BYOK respects that.

Your key, your costs

No LLM markup. Ever.

Pay your provider directly. Every review you run is billed to your key at Anthropic or OpenAI list rates — not marked up by us. If they drop prices, your costs drop the same day.

Spend-controlled by design

Your budget sets the limit.

Set spend limits directly on your provider account — CodePulse costs can’t run away. No fair-use downgrades, no surprise overages, no “unlimited” asterisks.

Or let us handle it

Flat per-seat pricing, hourly rate limit.

Prefer a predictable number per engineer? Team and Business ship with managed model access — 5 or 15 reviews per hour per dev respectively under fair-use. Most teams never feel the ceiling.

No per-review charges on any tier. Mix BYOK and managed across workspaces if you want. Start free, swap any time.

Pricing

Per developer. Unlimited reviews.

Start on BYOK with your own Anthropic or OpenAI key — or let us handle it. Every tier ships with Swift, Kotlin, Python, TypeScript, and Ruby reviews plus one-click auto-fix.

10 free reviews on any managed tier. No credit card. No time limit — try it at your pace.

Technical pick

BYOK

$6/ dev / month
Your provider. Your key. Your bill.
  • Anthropic or OpenAI — your key, your model, no ceiling
  • Smart dependency caching (fast cold-starts)
  • Private repos, auto-fix, Slack-native
  • Custom review rules per workspace
Get started

Business

$49/ dev / month
Deepest reviews on complex mobile PRs. Security layered in.

Why best for mobile: Deep Review on lifecycle & async code, SAST catches app-store-blocking security issues, custom rules encode your team’s conventions.

  • Unlimited reviews†
  • Deep Review — our most capable model, automatic on complex PRs
  • Semgrep SAST pre-review
  • Custom review rules per workspace
  • 15 reviews / hour / dev
Start free trial

Team

$29/ dev / month
Managed for you. Predictable monthly bill.
  • Unlimited reviews†
  • A frontier model on every review
  • Auto-fix from Slack
  • 5 reviews / hour / dev
Start free trial

Every plan runs frontier-class models, and we upgrade the day a better one ships — no price change, nothing to migrate.

† Unlimited reviews under our fair-use policy. Active developers are those who open at least one PR in a billing period. Need SSO, audit logs, or self-hosting? Get in touch →

FAQ

Questions mobile teams actually ask.

Does it actually understand Swift idioms, or is it just generic AI?
CodePulse runs sourcekit-lsp (the Swift language server) alongside Claude. Every review has real symbol resolution, type inference, and import context — so it catches retain cycles, force-unwraps, @MainActor violations, and SwiftUI state misuse. It isn't guessing from tokens; it's reading the code the way Xcode does.
Does it work with React Native and Flutter?
Yes. React Native reviews get TypeScript + JavaScript LSP context. Flutter reviews get Dart analyzer context. And when you have Kotlin or Swift native modules alongside, CodePulse switches automatically based on the file path. No config needed.
How does it handle monorepos?
CodePulse picks the right language server per file path automatically. A PR that touches iOS Swift, Android Kotlin, and shared TypeScript all in one commit gets three language-server-backed passes in a single review — no split PRs, no separate runs. Works the same whether your mobile lives alongside a backend service, a web app, or infra code.
Does it conflict with GitHub Copilot Review?
They can coexist — CodePulse posts its comments under its own App identity, so findings stay clearly attributed. Some teams run both (Copilot for breadth, CodePulse for mobile & architecture depth). If you’d rather only see CodePulse, disable Copilot Review per-repo from GitHub’s repo settings; nothing on our side needs to change.
What GitHub access does it need?
CodePulse installs as a scoped GitHub App. You pick the exact repositories it can see — never org-wide. The App needs read access to pull request contents (to review them) and write access to push auto-fix commits and post inline comments. You can revoke the install in one click from your GitHub settings; the next review in Slack will fail cleanly with a clear error message.
What happens if the auto-fix breaks my build?
Auto-fixes are plain git commits on your branch — nothing destructive, no hidden state. Your existing CI runs against the new commit. If anything goes red, a single git revert <sha> (or the “Revert commit” button in GitHub) reverses it in one line. We also only ever touch the branch we just reviewed — never your default branch directly.
Where does my code go? Is it stored?
Each review runs in an ephemeral container in our infrastructure: clone your branch, run the review, post the comments, shut down. Nothing is retained beyond the review itself. BYOK doesn’t change where the review runs — CodePulse still runs the review, you just supply the API key so your own provider account is billed for the LLM call. We don’t train on your code and we don’t share it with third parties.
Which model does it use?
Always a frontier-class model. We run the strongest one available and upgrade as new ones ship, which is why we don’t pin a version to a plan — you’d be stuck on it.
Team runs a frontier model on every review. Above fair-use thresholds, Team reviews route to a faster, lighter model for the rest of the billing period — less depth on complex PRs, but still language-server-backed.
Business adds Deep Review: our most capable model, engaged automatically on complex PRs (long diffs, async/lifecycle code, cross-file refactors). No fair-use downgrade on Business.
BYOK runs whatever you configure on your own Anthropic or OpenAI key — you pick the model, and you can pin a version. No ceiling.
Can I use my own API key?
Yes — BYOK is a first-class tier, and it works with an Anthropic or an OpenAI key. You pay your provider directly; we charge a smaller platform fee per seat. Recommended for teams that already track LLM costs or want tight spend control. Your key lives encrypted in your workspace settings.
What if a review is wrong — can I correct it?
Yes, without retraining lag. Custom review rules (Business tier) let you encode your team’s conventions — stop flagging patterns you don’t care about, steer toward ones you do. Rules take effect on the very next review. Reviews also use fresh context each run, so there’s no stale model memory to wait out when you change your mind.
What happens after the trial?
Pick a plan or stop using it. We don't auto-charge at trial end. Every workspace keeps access to its review history regardless.
Install & first review

Four clicks. Under five minutes.

  1. 1
    Add the Slack app OAuth handshake, 30-second read, click Authorize. ~1 min
  2. 2
    Pick the repos to review Scoped GitHub App: tick the specific repos, not org-wide. ~2 min
  3. 3
    Paste a PR link in any channel First review posts back in the thread in 1–3 minutes.

No credit card, no CLI, no config file to commit. Just the three installs and a PR link.

Give your mobile PRs the review they deserve.

Slack install → GitHub repo pick → paste a PR link. Under five minutes, no credit card.

Install in Slack