How I Actually Use AI as a Developer (And Why Most People Use It Wrong)
There's a pattern I see constantly: developers open ChatGPT or Claude, type "write me a function that does X," get back some code, paste it in, and when it breaks — they blame the AI. The tool isn't the problem. The usage pattern is.
AI assistants are not search engines with better grammar. They're more like a very fast, very well-read junior developer who has never actually run your code, doesn't know your codebase, and will confidently tell you wrong things if you let them. Once you internalize that, your usage changes completely.
This post is about how I actually use AI day to day — the tools, the habits, the prompt structures, and the mental model that makes it useful instead of a time sink.
The Mental Model: AI as a Thinking Partner, Not a Code Vending Machine
The first shift is conceptual. AI doesn't replace thinking — it accelerates it. When I'm stuck on an architecture decision, I don't ask "what's the best way to do X?" I describe my constraints and ask it to help me think through tradeoffs. That's a very different conversation.
Good usage looks like a rubber duck that talks back. Bad usage looks like outsourcing your brain.
The developers I've seen get the most value treat AI like this:
- For exploration: "I want to understand how X works at a lower level — walk me through it, then I'll ask questions."
- For acceleration: "Here's the boilerplate I always write for this pattern. Generate it, I'll review it."
- For review: "Here's my implementation. What am I missing? What would break under load?"
- For documentation: "Here's this function. Write a docstring that covers edge cases."
The developers who get frustrated use it like Google but slower.
The Tools I Actually Use
Claude (Anthropic)
My primary assistant. Better at reasoning through ambiguous problems than it is at producing large code blocks in one shot. I use it when I need to think through something — architecture, debugging a weird behavior, understanding a system I haven't touched before.
What it's genuinely good at: holding long context, reasoning about tradeoffs, explaining things at the right level if you tell it who you are.
ChatGPT (GPT-4o)
I keep this around for a second opinion. If Claude gives me an answer I'm not sure about, I'll ask GPT the same question differently. Not because one is "better" — they have different failure modes, and cross-checking catches some of them.
Also better for certain kinds of quick code generation where I just want something to compile and I'll clean it up myself.
Cursor / GitHub Copilot
For in-editor completion and small refactors. This is where "AI as autocomplete" actually earns its place. I use Cursor with Claude as the backend. It's aware of my file context, so it's much more useful than a web chat window for anything that touches multiple files.
The key insight: in-editor AI and chat AI solve different problems. One completes what you're already writing. The other helps you figure out what to write.
Graphite (graphite.dev)
This one is less obvious but it belongs here. Graphite is a stacked PR workflow tool, and it has AI-powered PR descriptions and review assistance. If you work on a codebase with real PR discipline, this saves a non-trivial amount of time. The AI-generated diff summaries are actually decent because the context (your code diff) is precise.
What I use it for: auto-generating PR descriptions, stacking changes cleanly, and getting a first-pass review suggestion before I ask a human.
It's not a "chat with AI" tool — it integrates AI into the git/PR workflow, which is where friction actually lives.
Phind / Perplexity (for research)
When I need to understand something in the ecosystem — "what are people actually using for X in production in 2025" — I use Perplexity because it cites sources. AI hallucinating library names is a real problem. Having citations makes it verifiable.
Phind is specifically tuned for developer queries and tends to give better results for technical documentation-style questions.
Prompt Structure That Actually Works
This is the part most tutorials skip. The difference between a useful response and a useless one is almost entirely in how you frame the question.
1. Set context upfront, every time
Don't assume the model knows your stack, your constraints, or your skill level. Tell it.
I'm building a Go HTTP service with chi router and PostgreSQL.
I don't use ORMs — raw sqlx. The service handles authentication.
That one paragraph changes every answer you get in the conversation. Without it, the model defaults to the most generic, most popular answer — which is probably not what you need.
2. Ask for reasoning, not just output
# Bad
Write a Redis caching layer for this endpoint.
# Better
I want to add Redis caching to this endpoint.
Before writing any code, tell me what TTL strategy makes sense
given that this data changes on user actions, and what invalidation
approach you'd recommend. Then we can write it.
The second version forces the model to think before generating. You'll catch bad assumptions before they make it into code.
3. Give it your code, not a description of your code
# Bad
I have a Django view that authenticates users. How do I add rate limiting?
# Better
Here's my view: [paste code]
I want to add per-IP rate limiting. I'm already using Redis for session caching.
What's the cleanest way to do this without a third-party package?
Models operate on what you give them. Descriptions introduce your interpretation. The raw code is the ground truth.
4. Tell it to push back
If you think my approach is wrong, say so before writing the code.
I'd rather have the right design than a fast answer.
This one line meaningfully changes outputs. By default, models are agreeable. They'll implement your bad idea cleanly. Explicitly asking for pushback gives them "permission" to tell you something is off.
5. Constrain the scope
Write only the cache invalidation function.
Don't rewrite the whole handler — I'll integrate it myself.
Smaller scope = better output. When you ask for large things, you get large things with more surface area for errors. Ask for the piece you can't write quickly yourself.
Habits That Make a Real Difference
Treat every code output as a first draft
I never paste AI-generated code directly into production without reading it line by line. Not because it's usually wrong — it's usually fine — but because the cases where it's wrong are subtle. A hallucinated function that compiles and seems to work but has an edge case bug is worse than code that visibly fails.
Read it. If you don't understand a line, ask. That's not a weakness — that's how you learn and how you catch problems.
Use it to rubber-duck your own ideas first
Before asking for a solution, explain your current thinking:
Here's what I'm planning to do and why: [your plan]
Does this make sense? What am I missing?
Half the time I work through the problem in the process of writing the prompt. The other half, I get useful friction I wouldn't have found alone.
Keep a prompt library
If you've found a framing that works for a type of problem — code review, writing tests, explaining a concept — save it. I have a small notes file with prompts I reuse:
- "Review this for correctness, not style. Flag anything that could break under concurrent access."
- "Write tests for this function. Focus on edge cases. Don't test the happy path — I have that covered."
- "Explain this like I've used [X] but never [Y]."
The first time you write a good prompt is work. After that it's a template.
Don't use AI for things you need to actually learn
This is a real tradeoff. If I'm learning something new — Go concurrency patterns, a new database I haven't used before — I deliberately don't lean on AI for the first few days. I want the friction. The struggle is where the mental model forms.
AI is incredibly good at removing friction. That's also its biggest danger. Some friction is load-bearing.
Where AI Genuinely Earns Its Place in My Workflow
To be concrete: here's where I actually save real time.
Boilerplate and scaffolding. The boring parts of starting a new service — config structs, middleware wiring, Dockerfile — I generate and review. Zero thinking required, and AI is reliable here.
Writing tests for existing code. Describing behavior is hard. Generating test cases from existing code is something models do well, especially for edge cases you're likely to forget.
Explaining unfamiliar code. I drop in a function I've never seen before and ask "what does this do, and what could go wrong?" Fast way to get oriented.
First-pass PR descriptions. I hate writing these. AI is decent at summarizing diffs. I edit, not write from scratch.
Translating between languages. "Here's this Go function — what's the idiomatic Python equivalent?" Useful when I'm moving between parts of a codebase with different stacks.
Where It Consistently Fails
Anything requiring knowledge of your specific system. It doesn't know your database schema, your traffic patterns, your team's conventions. It will make assumptions — often reasonable ones — but they're not yours.
Security-sensitive code. Not because it always gets it wrong, but because the cost of a subtle mistake is high. I use AI to understand security concepts, not to generate auth code I'll deploy without deep review.
Debugging runtime issues. "My service crashes intermittently under load" is not a problem AI can solve from a description. It needs data — logs, traces, metrics. It can help you interpret that data once you have it, but the legwork is yours.
Up-to-date ecosystem knowledge. Training data has a cutoff. For anything ecosystem-specific — "what's the current standard way to do X in Go 1.23" — verify with the actual docs.
The Honest Summary
AI tools are genuinely useful, and the gap between developers who use them well and those who don't is growing. But the people who use them well aren't the ones who use them most. They're the ones who have a clear sense of where the tool is reliable, where it isn't, and how to structure their input to get signal instead of noise.
The investment is in learning to use the tool well — prompt habits, the right tool for the right job, and knowing when to close the tab and think for yourself.
That last part is still non-negotiable.
# Comments (0)
No comments yet. Be the first.