AI is not going to take your job. A developer who uses AI will outperform one who does not, and that is a different claim.
The problem was never using AI. The problem is expecting AI to think for you. It is a power tool, not a magic wand. You still own architecture, product decisions and quality.
Three levels
Most developers move through three levels. Start where you are comfortable and level up as your process improves, not before.
| Level | Mode | What it looks like |
|---|---|---|
| 1 | Chat assistant | Ask questions, get snippets, debug with context |
| 2 | Pair programmer | Inline suggestions, refactoring help, editor assistance |
| 3 | Coding agent | Multi-file tasks, tests, iterative fix loops with oversight |
The order matters. Level 3 with level 1 review habits is how people end up shipping code they cannot explain.
Tools, and when
The landscape is crowded. Start with a small stack and expand only when you have repeatable wins.
| Stage | Tools | Best for |
|---|---|---|
| Questions | Claude, ChatGPT | Reasoning support, explanations, debugging direction |
| Editor work | GitHub Copilot, Cursor | Inline speed, refactoring, faster feature loops |
| Agentic work | Claude Code, Windsurf, Cline | Multi-file execution, repo-wide operations |
Open-weight models can run locally for better privacy and predictable cost, which matters when your codebase has strict data constraints.
The one skill that multiplies everything
Prompt quality. Be explicit about stack, constraints and expected behaviour.
| Example | |
|---|---|
| Vague | "Make me a login page." |
| Specific | "Create a Next.js 14 and TypeScript login page with Zod validation, loading and error states, Tailwind UI, and API route handling." |
Five habits do most of the work:
Be specific about stack. Framework, language and libraries up front, not discovered halfway through.
Describe what, not every implementation detail. Give goals and constraints. Over-specifying the how wastes the thing you are paying for.
Provide context. Code snippets, file paths, actual error output.
Ask for reasoning. Request trade-offs and rationale, not just code. The rationale is how you catch a wrong answer that compiles.
Iterate instead of restarting. Refine incrementally. Starting over discards everything the model already got right.
A real feature workflow
Plan, scaffold, build, test, ship. The planning prompt does the heavy lifting:
I am building a job application status tracker.
Stack: Next.js 14, TypeScript, PostgreSQL, Prisma.
Requirements:
- statuses: pending, reviewed, accepted, rejected
- employer can update status
- user sees updates in dashboard
- mobile responsive
Questions:
1) Best schema?
2) Server actions vs API routes?
3) Real-time updates approach?
4) Edge cases to cover?
Give me a step-by-step implementation plan.
Notice it asks questions rather than requesting code. The plan is the artifact worth getting right.
The five common mistakes
| Mistake | What to do instead |
|---|---|
| Copy-paste without understanding | Read and explain generated code before shipping |
| Vague prompts | Specify stack, constraints, expected behaviour |
| Restarting too often | Iterate on prior responses |
| Asking for everything at once | Break into small components, test as you go |
| Blind trust in security-sensitive code | Manually review auth, validation and data access |
If you cannot explain the code, do not ship it.
What it is good at, and what it is not
| AI excels at | AI struggles with |
|---|---|
| Boilerplate, CRUD, repetitive code | Business logic unique to your domain |
| Generating tests and docs | Architecture choices in your org's context |
| Debug support, quick conversions | Security-critical implementation details |
The right-hand column is not a temporary limitation to wait out. It is the column where the answer depends on facts about your organisation that are not in any codebase.
Your first week
Days 1 and 2, ask about your existing code: explanations and bug finding. Days 3 and 4, add editor tooling and notice where suggestions actually help. Day 5, build one small feature end to end. Day 6, generate tests for code already merged. Day 7, review which prompts worked and keep a playbook for your stack.