Everyone has an opinion on AI coding tools. Half the internet says they will replace developers; the other half says they produce garbage code. After using them daily for over a year, I have a more boring take: they are just tools. Here is exactly how I use them, where they genuinely help, and where I have learned to ignore them.
The Tools I Actually Use
I am not going to pretend I tried every AI tool and picked the perfect stack. Here is what stuck:
- Claude (Anthropic) — my primary assistant for thinking through architecture, writing long-form content, and debugging complex logic
- Cursor — my editor; the AI autocomplete and inline editing is baked into how I code now
- GitHub Copilot — I keep it as a fallback inside VS Code when I am not in Cursor
- Perplexity — for quick research without the hallucination risk of asking a chatbot directly
Where AI Tools Genuinely Help Me
Boilerplate and scaffolding
This is the clearest win. Writing a new API endpoint, a new React component, a migration file — anything that has a predictable shape — I let the AI draft the skeleton and I review it.
What used to take 10 minutes of copy-paste-adjust takes about 90 seconds.
// I describe what I want:
// "Create an Express route for updating a user profile.
// Validate name and email. Use zod for validation."
// Cursor generates this, I review and adjust:
import { z } from 'zod';
const schema = z.object({
name: z.string().min(1).max(100),
email: z.string().email(),
});
router.put('/profile', async (req, res) => {
const parsed = schema.safeParse(req.body);
if (!parsed.success) return res.status(400).json(parsed.error);
const updated = await updateUser(req.user.id, parsed.data);
res.json(updated);
});Explaining unfamiliar code
When I encounter a codebase or library I have never used, I paste the relevant code into Claude and ask it to explain what it does. This cuts my “orientation time” in a new project significantly.
Writing tests
I genuinely dislike writing unit tests for straightforward logic. AI tools write decent tests for pure functions. I still write integration tests and edge case tests myself — the AI tends to miss those.
Regex and one-off scripts
Nobody enjoys writing regex. I just describe the pattern in plain English and get a working regex back in seconds. Same for one-off data transformation scripts — describe the input and output, get a working script.
Where AI Tools Have Let Me Down
Architecture decisions
This is the most dangerous area. AI tools are confident and fluent, which makes it easy to trust their architectural suggestions. But they optimise for plausible-sounding answers, not for your specific constraints — your team size, your existing tech debt, your deployment environment.
I stopped asking AI for architecture advice. I use it to help me implement an architecture I have already decided on.
Security-sensitive code
Authentication flows, permission checks, input sanitisation, cryptography — I write this myself or use well-audited libraries. AI-generated security code has subtle bugs that pass code review because they look reasonable. Do not trust it here.
Anything requiring domain context
If the AI does not know the business rules, the data model, or the history of why a decision was made, it will invent plausible-sounding logic that is wrong. Context is everything.
The Workflow Change I Did Not Expect
The biggest shift in how I work is that I now spend more time reviewing and editing than writing from scratch. My output volume went up, but so did the cognitive load of reviewing generated code carefully.
The developers who struggle with AI tools are often the ones who do not review outputs critically. The ones who thrive treat AI like a junior developer: useful, fast, but requires supervision.
My Actual Daily Workflow
A typical feature looks like this:
- Plan in my head (no AI) — I think through the approach before touching a keyboard
- Scaffold with AI — generate the structure, then immediately read every line
- Write the logic myself — business logic, state transitions, edge cases
- Tests via AI, then review — accept the obvious ones, rewrite the edge case tests
- Debug with AI help — paste the error, explain the context, use the suggestion as a starting point
Total AI involvement: maybe 30-40% of my coding time. The rest is still me thinking and writing.
Conclusion
AI coding tools are genuinely useful in 2026. They are not replacing senior developers any time soon, because the hard part of software development is not typing — it is deciding what to build, how to structure it, and how to handle the cases that do not fit the happy path.
Use them for what they are good at. Stay sharp on everything else.