Every junior developer I talk to is worried about the same thing: AI can already write the code I was hired to write. That is partly true. It can produce a CRUD endpoint, a React component or a SQL query in seconds. What it cannot do is decide whether the endpoint belongs there, notice that the query will lock a table under load, or explain to a reviewer why the trade-off is acceptable.
The job is shifting from typing code to directing, reviewing and debugging it. That makes fundamentals more valuable, not less.
Learn to debug before you learn another framework
Debugging is the skill that compounds. Learn to read a stack trace, reproduce a bug reliably, bisect a change, inspect network requests, read logs and use a profiler. When AI-generated code fails, you need to form a hypothesis and test it, not ask for another variation.
A practical exercise: take a small open-source bug, reproduce it, write a failing test, fix it, and explain the root cause in five sentences. Do that ten times and you will be more useful than someone who has watched twenty tutorials.
Get specific about data
Most application bugs are data bugs. Learn SQL beyond SELECT: joins, indexes, transactions, isolation levels and query plans. Learn how to model one-to-many and many-to-many relationships, and when to denormalise. Learn what happens when two requests update the same row at once.
EXPLAIN ANALYZE
SELECT id, status
FROM orders
WHERE customer_id = $1
ORDER BY created_at DESC
LIMIT 20;If you can read that plan and explain why it uses an index or a sequential scan, you are already ahead.
Understand the request path
You do not need to memorise every HTTP header. You do need to know what happens between a click and a database row: DNS, TLS, the request, authentication, authorization, validation, the handler, the query, the response, the browser render. When something is slow or broken, that map tells you where to look.
Write tests that describe behaviour
AI is good at generating tests that mirror the implementation. That is not the same as testing the behaviour. Write the test first for a bug fix: given this input, the system should do this. Keep the test small and readable. A test suite you trust lets you accept AI suggestions faster because you can verify them.
Use AI as a pair, not an oracle
The productive pattern is small diffs. Ask for one function, read it, run it, test it, then move on. Do not paste a 400-line change you cannot explain into a review. If you cannot describe what each part does, you are not ready to ship it.
- Ask for the smallest change that solves the problem.
- Make it explain the trade-offs, then verify the claims.
- Run the tests and read the diff before accepting.
- Never let it invent an API; check the docs.
- Keep a notes file of patterns you had to fix repeatedly.
What to ignore
Ignore framework churn for its own sake. Once you know one component model and one backend framework, the next one is a week of translation, not a new career. Ignore memorising algorithm puzzles as your main strategy; practise enough to recognise patterns, then spend the rest of the time building. Ignore 'prompt engineering' tricks that will be obsolete next quarter; clear writing and precise requirements are the durable version.
A 90-day plan
- Weeks 1–2: build and deploy a small app with auth, a database and one external API.
- Weeks 3–4: add tests, logging and a CI check; break it on purpose and debug it.
- Weeks 5–6: learn SQL indexing and transactions; profile one slow query.
- Weeks 7–8: read a codebase you did not write; fix two issues and write up the cause.
- Weeks 9–10: add an AI feature with a token budget, eval cases and a fallback.
- Weeks 11–12: write a public post about one trade-off you made and why.
The portfolio that stands out is not a list of tutorials. It is one real application with a clear README, a few honest trade-offs, tests, and a deployed URL. Add a short write-up of a bug you fixed and how you found it. That is more convincing than ten cloned dashboards.
What to remember
- Debugging, SQL and the request path are the highest-leverage fundamentals.
- Use AI for small, verifiable diffs, not for changes you cannot explain.
- Write behaviour-focused tests; they are how you verify generated code.
- Build one real deployed app and write about its trade-offs.
- Communication and ownership are still the differentiators in hiring.