15 AI Coding Tips from Developers Who Actually Ship
There's a pattern we keep seeing: a developer tries Claude Code or Cursor, gets some decent results on a toy project, then hits a wall on anything real. They assume the tool isn't good enough yet. Usually, it is. They're just managing context like it's infinite and free.
We spent the last few months collecting workflows from developers who use AI coding agents daily — not for demos or blog posts, but for production code that ships. The single biggest insight across all of them: the bottleneck isn't prompt quality. It's context management.
Here are 15 concrete tips, each attributed to a real practitioner. No theory. Just stuff that works.
Session Discipline
1. Don't wait for auto-compact
“If you hit autocompact during a chat, it's already too long. You should've exported the relevant bits to a markdown file and reset context already.” — theshrike79, Hacker News
The consensus is blunt: manual compaction at 50% context, not 95% when auto-compact kicks in. Quality degrades well before you hit the token limit, and the model's own compaction is lossy. By the time it auto-compacts, you've already been getting worse outputs for a while.
2. Failed explorations poison everything
“Context poisoning from failed explorations is the #1 problem. If the LLM spends 10K tokens investigating a bad solution and you redirect it, it has trouble ignoring all that bad exploration against your 10 lines of 'no, do Y instead.'” — bgirard, Hacker News
The fix isn't arguing with the model. It's git revert and a fresh session. Boris Tane puts it bluntly: “When something goes in a wrong direction, I don't try to patch it. I revert and re-scope.” Every time.
3. Write handoffs, not histories
Ask the current session to write a structured handoff summary — goals, decisions, what worked, what didn't — then start fresh and give the new session only that file. This “document and clear” pattern replaces the fragile hope that compaction preserves what matters. Some developers have turned off auto-compact entirely and use custom /handoff commands before every session clear.
CLAUDE.md Done Right
4. Never send an LLM to do a linter's job
“Code style guidelines in CLAUDE.md are a waste of context — they add irrelevant tokens, degrade instruction-following across all rules, and the LLM should already be pattern-matching from your existing code.” — Kyle, HumanLayer blog
Claude Code's system prompt already uses roughly 50 of the ~150-200 instruction slots an LLM can reliably follow. Every line you add to CLAUDE.md dilutes compliance with every other line. Instead, set up hooks that run your formatter and linter automatically. Deterministic tools for deterministic rules.
5. Use it as a directory, not a document
Keep architecture.md, checklist.md, and component docs as separate files. CLAUDE.md tells the model what to read based on what it's trying to do. This “progressive disclosure” pattern prevents context bloat while keeping everything discoverable. Per-directory CLAUDE.md files load automatically when the model touches files in that directory — contextual and efficient.
6. Use a canary phrase
“A friend tells Claude to always address him as 'Mr Tinkleberry' — when it stops, he knows the instructions have fallen out of effective context.” — nico, Hacker News
Delightfully simple. Costs nothing. Another variant: an instruction to “tell me how you slept” on startup. If the model plays along, your files parsed correctly. These compliance canaries save real debugging time.
Planning vs. Execution
7. Let AI research, you build
“Instead of having Claude make a PR, ask it to output a Markdown doc with a deep, detailed guide for implementing the change. Then read the doc and code it yourself with Cursor tab-complete. I cannot emphasize enough how much I prefer this.” — Geoffrey Litt, Design Engineer at Notion
This reframes the AI from autonomous coder to research assistant. A kinda-dumb-but-fast model can be surprisingly smart if it's working off good plans from a smart model.
8. Plans are files, not chat messages
“I use my own .md plan files rather than Claude's built-in Plan Mode. After Claude writes the plan, I open it in my editor and add inline notes. Then I tell Claude: 'Address all the notes. Don't implement yet.' This cycle repeats 1 to 6 times. I want implementation to be boring.” — Boris Tane
The key: a plan file on disk is a persistent artifact that survives compaction in full fidelity. Chat-based plans are fragile. File-based plans are durable.
9. Force reconnaissance before implementation
“Before implementing, find 2 similar examples in the repo and explain the pattern. Then follow that pattern.” — Boris Cherny, Claude Code creator
This tiny directive prevents the AI from inventing patterns that already exist in your codebase. Instead of “Make a dropdown component,” say “Make a dropdown component similar to the Select component in @components/Select.tsx.” Tiny change, dramatically better results.
Verification Loops
10. Give the model a way to check its work
“Every time someone tells me 'AI coding doesn't work for me,' the first thing I ask is: what's your validation loop? Nine times out of ten, there isn't one.” — John Kim, Push To Prod
Include test, build, and lint commands in your agent config. When the model can run a build, see the errors, and fix them in a loop, it self-corrects. Boris Cherny says this combined with Plan Mode gives a 4-9x improvement on harder tasks.
11. TDD works better for AI than for humans
“Add one line to your prompt: 'Write tests first, then the code, then run the tests and update the code until tests pass.'” — Steve Sewell, Builder.io
This transforms the AI from a one-shot code generator into an autonomous problem-solver with a built-in correctness signal. If you take nothing else from this post, try this one.
Multi-Session Tactics
12. A/B test your AI's work
“Something stupid I've been doing: having Claude spin up three different routes with the exact same feature — /one /two /three — then I compare them.” — Theo Browne
Some developers run 5+ parallel sessions, each on its own git checkout. Not branches — full separate checkouts to avoid conflicts. It sounds excessive until you realize the model is doing the work, not you.
13. Use the smartest model, not the fastest
The counterintuitive insight: the bottleneck isn't generation speed — it's human time spent correcting mistakes. A slower, more capable model that needs less steering has a lower total cost of interaction. Use the smartest model for planning, faster models only for well-scoped execution.
Power Moves
14. “Ultrathink” is real
Simon Willison reverse-engineered Claude Code's internals and found hidden thinking-budget triggers. “Think” < “think hard” < “think harder” < “ultrathink.” The last one allocates the maximum thinking budget. Without emphatic language in research directives, the model will skim.
15. Hooks beat instructions
Hooks are deterministic. CLAUDE.md instructions are advisory. Run a PostToolUse hook to auto-format code after every edit. Run a Stop hook that type-checks and feeds errors back. If you find yourself doing the same manual step after the model finishes something, automate it with a hook.
The Bottom Line
The developers getting the most from AI coding agents in 2026 aren't writing better prompts. They're building better environments for the model to work in. Three patterns do the heavy lifting: plans as persistent files (not chat messages), verification loops (tests + linters + browser checks), and aggressive session hygiene (document, clear, restart). Everything else is a force multiplier on those three.