When you work alone, an AI coding assistant can feel like a second developer who never gets tired. That is useful, and it can also go wrong. A second developer who writes code quickly, never pushes back, and never remembers yesterday's decisions can fill your repo with code that works today and confuses you in three months. Nobody else is going to review it.

This post covers a setup that keeps the speed and keeps you in charge: which tasks to hand off, how to give the assistant useful context, how to review what it writes, and how to check whether it is really saving you time.

Decide what the assistant is for

Don't treat every task the same way. Sort your work into three groups and handle each one differently.

Good to hand off

  • Boilerplate with a clear pattern already in the repo: a new settings screen like the existing ones, another API client method, another model with a mapper.
  • Test scaffolding for code you have already written and understand.
  • One-off scripts: renaming assets, converting a CSV, generating localization keys.
  • Explaining code you didn't write, such as a dependency's internals or an old module of your own.
  • Mechanical refactors where the compiler and your tests will catch mistakes.

Hand off with care

  • Anything about concurrency, caching, or app lifecycle. Generated code here often looks right and fails only on a real device under real conditions.
  • Database migrations and anything that touches persisted user data.
  • UI layout. The output usually compiles, but check it on small screens, with large text sizes, and with accessibility settings turned on.

Keep for yourself

  • Purchase, subscription, and entitlement logic.
  • Authentication, encryption, and anything involving keys.
  • Architecture decisions. You can ask for options, but you make the call and write it down.

The rule of thumb: if a subtle bug would cost a user money or data, or cost you a store review, write the code yourself and ask the assistant to review it, not the other way round.

Give it context that lives in the repo

Most bad suggestions come from missing context. The assistant doesn't know you avoid a certain library, that networking goes through one wrapper, or which command runs the tests. Most assistants can read a project instructions file. Keep one at the root of the repo and commit it.

# Project notes for coding assistants

## Commands
- Build: ./scripts/build.sh
- Unit tests: ./scripts/test.sh
- Lint: ./scripts/lint.sh

## Conventions
- All network calls go through ApiClient. Do not create new URLSession/OkHttp clients.
- No new third-party dependencies without asking first.
- User-facing strings go in the localization files, never hard-coded.

## Do not touch
- billing/ (purchase and entitlement logic)
- migrations/ (write new migrations only when asked)

Keep it short and specific. A long file of general advice gets ignored by people and models alike. When the assistant makes the same mistake twice, add a line. Over time the file becomes a good record of your project's rules, and it helps you too when you come back after a few months away.

Work in small, reviewable units

The biggest risk with an assistant is a diff too large to read carefully. The fix is to work in small pieces:

  1. One task per branch. Describe it in a sentence before you start. If you can't, the task is too big.
  2. Start from a clean working tree. Then the diff shows only what the assistant did.
  3. Ask for a plan first on anything bigger than a single function. Read the plan, change it, then let it write code.
  4. Read the full diff before you commit. Not just the summary the assistant gives you.
  5. Commit often so you can roll back one bad step without losing good work.
git switch -c task/export-csv
# ... assistant session ...
git diff --stat          # how much changed, and where?
git diff                 # read it
git add -p               # stage hunk by hunk, skip what you don't want
git commit -m "Add CSV export for entries"

git add -p is underrated here. It makes you look at every hunk, and you can leave out the unrelated "improvements" assistants like to slip in.

Let tests be the referee

An assistant will happily say a change works. Don't take its word for it. Run the tests yourself, or make sure the tool actually ran them and shows the output.

A pattern that works well: write or approve the test first, then ask for the implementation.

  • Describe the behavior and ask for a failing test.
  • Read the test. Is it really checking the behavior, or is it checking a mock?
  • Run it and confirm it fails for the right reason.
  • Then ask for the implementation, and run the tests again.

Watch for one failure mode in particular: when a test is hard to pass, assistants sometimes weaken the test, by loosening an assertion, adding a skip, or mocking the code under test. Treat any diff that touches test files and implementation files together with extra suspicion.

A review checklist for generated diffs

Keep this list somewhere handy and go through it before each commit:

  • Do I understand every line? If not, ask for an explanation, or rewrite it until you do.
  • New dependencies? Check the package name exists and is the one you meant. Assistants sometimes suggest packages that sound plausible but don't exist or aren't maintained.
  • Duplicate helpers? Search the repo for an existing function that already does this.
  • Error handling: are errors handled, or swallowed in an empty catch block?
  • Threading: does UI work stay on the main thread, and heavy work stay off it?
  • Deprecated APIs: suggestions can reflect older SDK versions. Check against current platform docs.
  • Hard-coded values: URLs, timeouts, strings, keys.
  • Unrelated changes: reformatting, renamed variables, or touched files outside the task.

Keep secrets and user data out of the conversation

Whatever you paste into a prompt, or whatever the tool reads from your working directory, may leave your machine. Check your assistant's data retention and training settings, and set them on purpose. Then make leaks unlikely:

  • Keep keys in environment variables or a secrets manager, never in tracked files. Our post on keeping secrets out of your repos covers a setup that also protects you here.
  • If your tool supports ignore rules for what it can read, exclude .env files, signing material, and local databases.
  • Don't paste real user data, crash logs with personal information, or support emails into a prompt. Redact first, or build a synthetic example.

Watch for slow failure modes

Some costs don't show up in a single session. Check for them every few weeks:

  • Dependency creep: compare your dependency manifest with how it looked a month ago.
  • Style drift: the same thing done three different ways in three files.
  • Unfamiliar territory: parts of the codebase you couldn't debug without the assistant. If a module only works while the tool is available, that's a risk for a solo developer.
  • Skill atrophy: now and then, write something nontrivial by hand. That's how you keep the judgment you need to review generated code.

Check whether it's actually helping

It's easy to feel faster without being faster. You don't need a full study. A plain log is enough. For each task, write down:

date | task | assisted? | time spent | rework later? (y/n, why)

After a few weeks, look for patterns. You'll probably find some kinds of tasks where the assistant clearly saves time, and others where you spent more time fixing its output than you would have spent writing the code yourself. Move those tasks into the "keep for yourself" group. The "rework later" column matters most, because a bug you find in two weeks costs more than the time you saved today.

If you also ship AI features inside your app, the same habit applies there. Measure before you trust, as we describe in building a small eval set before you ship an LLM feature.

Wrapping up

An AI coding assistant works best for a solo developer when it acts like a fast junior collaborator, not a co-owner of the codebase. Decide which tasks it gets, write your project rules down in the repo, keep diffs small enough to read, let tests decide what works, and keep secrets and user data out. Then check every so often whether the time saved is real. The goal is to ship faster and still understand every part of your app.