People ask which model or which tool. After five weeks building ParkEase with an AI agent, my answer is that the setup around the model mattered more than the model. Here are the habits that made the biggest difference, roughly in order of payoff.
Before you write a line
1. Write the rules down once. One instruction file the agent reads every session: your stack, the five to ten rules that matter most, and what's forbidden. Especially what's forbidden. "Drizzle, NOT TypeORM" saves an argument every single session.
2. Record decisions, not just code. When you decide something structural (money is integer paise; the database enforces double-booking), write a short decision record with the why. The agent will otherwise re-decide it, reasonably and differently, next week.
3. Make it think before it types. A brainstorming step before any feature surfaces the questions the task description didn't answer. It's the cheapest bug you'll ever fix.
While it builds
4. Tests first, real infrastructure. Have it write the failing test, then the code. And run integration tests against a real database in a container, not mocks. Mocks are a second implementation that agrees with your first.
5. Make it read before it guesses. The most expensive pattern I saw was the agent guessing an API, failing, guessing again. One rule ("read the docs and type definitions before writing code against a library") cut whole loops of retries.
6. Ask for the lazy version. AI over-builds by default. A "does this need to exist?" pass before every feature deleted more code than any refactor.
7. Show the UI, don't describe it. For anything visual, make it render two or three options and pick. You'll judge a picture in seconds; a paragraph about a picture, never.
Before you call it done
8. Demand evidence, not adjectives. "Thoroughly tested" isn't evidence. The test command and its output is. Make "verify before claiming done" a fixed step.
9. Review with narrow lenses. "Review this" gets a polite skim. "Find every swallowed error" or "find every query missing an index" finds things.
10. Run the real build, against the real thing, once. Every test in ParkEase was green when three bugs reached the first deploy. Booting the built image and clicking through it found them in minutes.
Across sessions
11. Keep a learnings file. Every fix that cost more than fifteen minutes becomes an entry the agent reads next time. The model has no memory; the repo can.
12. Turn repeated corrections into rules. If you've told the agent the same thing twice, the second time belongs in its instruction file, not the chat. "Never skip visual verification" started as me being annoyed and ended as a gate.
And one anti-habit
Don't parallelise for the sake of it. It's tempting to fan out five agents on every task. Each one rebuilds its context from scratch, and on one task that ate most of a week's usage limit. Use specialists for the diffs that deserve them, not by default.
Next: an opinion piece. I think the software development life cycle is quietly becoming something else, an AI development life cycle, and the parts that grow are not the ones you'd guess.
ParkEase is a peer-to-peer parking marketplace for India, built solo with Claude Code.
Code: https://github.com/Deonkar/parkease
Top comments (0)