After a few months of using Aider — the open-source AI pair-programming tool that lives in your terminal — as my daily driver, I noticed my sessions weren't random. They fell into the same six patterns. Writing them down as repeatable workflows changed my results more than any prompt trick.
The six workflows
1. Greenfield Scaffold. For a new tool or script: start from a spec, not a wish. Language and version, allowed dependencies, inputs, outputs, one concrete example. Scaffold the smallest runnable spine, run it yourself, and grow it later — never ask for the whole app in one prompt.
2. Feature Add on Existing Code. Add the files that will change, mark the files the model should only read (interfaces, schemas) as read-only, and ask for a plan before any code: which files change, what new behaviour appears, what could break. Read the plan critically. If the plan is wrong, re-plan — don't patch a bad plan with five micro-prompts.
3. Test-Driven Bugfix Loop. No failing test, no loop — without one, the model "fixes" by vibes. Write (or generate, then verify) a test that fails for the right reason, turn on auto-test with your test command, and prompt with the symptom plus "fix the code, not the tests". A good fix is small and explainable in one sentence.
4. Planned Refactor (Architect Mode). Precondition: a passing test suite. Ask the strong model for a file-by-file plan with one invariant — no behaviour changes — then let the editor model execute. A refactor never shares a commit with a feature.
5. Test Generation. Prompt for behaviour tests with named edge cases (empty input, Unicode, missing files), then do the step most people skip: mutate the code by hand — an off-by-one is enough — and confirm a test catches it. Tests that can't fail are decoration.
6. Onboarding to an Unfamiliar Codebase. Start with no files added and stay in ask mode: What does this project do? Where is the entry point? Trace a request through a feature — which files, in what order? Save the answers as notes. Only then make your first real change, in a small, well-understood corner.
The Git routine that makes this safe
Aider's real superpower is that every generation is a git commit you can inspect and reverse. My routine:
- One config change:
dirty-commits: falsein.aider.conf.yml, so Aider never commits my uncommitted work for me — and I still commit or stash my own work before a session, deliberately. - Review every AI change like a PR: read the diff hunk by hunk (especially deletions, tests, and anything touching config or data), then run the tests myself at least once per session, even with auto-test on.
- Know your undo ladder:
/undoin chat for the last Aider commit,git revertfor a later bad commit on a shared branch, and task branches as your blast-radius limiter — never let Aider work directly on your deployment branch while you're learning.
Pick the model per workflow, not per project
Architect mode for refactors, a cheaper model for test generation, your best model only where judgement matters. This cut my API spend more than any other single change.
Full disclosure: I packaged these workflows with the full Git safety guide (complete undo ladder, branching strategy, pre-push checklist), a cost-control guide with a model-selection matrix, and the templates I use (task brief, prompt starters, review/commit checklists, full .aider.conf.yml) as a $10 pack: https://whop.com/checkout/plan_Qnb9d21JZ7LEa
New to Aider? Start with the free Starter Kit instead — it covers installation and your first session: https://whop.com/checkout/plan_diZ6ymgxjRMz2
