Sefism Coding with AI Tools Roadmap

What this roadmap is

Coding with AI tools is Sefism's ten-stage roadmap for students and developers who use Claude Code, Cursor or GitHub Copilot and want to get real work done without losing the skills that make them engineers. It is not a list of tricks. It teaches a way of working: give the tool good project context, ask for small checkable changes, review and test everything it writes, run agents with deliberate permissions, and keep practising without it.

By the end you should be able to:

• explain what AI coding tools are good and bad at, and decide task by task whether to use one, which mode to use, or to write the code yourself
• set up your tool in a real repository with a short, accurate instructions file, scoped rules and secrets kept out of its reach
• turn a task into a small, specified prompt with a definition of done, and review every diff with a checklist before it is committed
• use tests, debugging evidence, permission rules, checkpoints and Git so agent changes are verified, reversible and safe
• keep your fundamentals sharp with regular AI-off practice, and ship a small real project with an agent plus a write-up of what you decided and what you caught

Who it suits, and who should start elsewhere

It suits students who already code and now use an AI tool for assignments and projects, and working developers whose team has adopted one. It assumes you can already write and read code in at least one language, because reviewing AI output is the core skill here.

If you are still learning your first language, do Programming foundations first; its advice is to keep code completions off while you learn. If you want to build AI products rather than use AI to build software, see AI engineering or AI agents and MCP.

Editions, prerequisites and time

You choose your tool: Claude Code (the default), Cursor or GitHub Copilot. The stages are the same, while setup, instructions files, permission controls and recommended docs follow your tool: CLAUDE.md and .claude/settings.json for Claude Code, .cursor/rules and Run Modes for Cursor, .github/copilot-instructions.md and tool approvals for Copilot. AGENTS.md is covered for mixed teams.

The estimate is about 81 hours across 10 stages:

• A student with 10 to 12 hours a week finishes in roughly 11 weeks. Use your real coursework or project as the material: each stage changes how you do work you already have.
• Someone working full time with about 5 hours a week should plan for around 20 weeks. The checklists are designed to be applied on the job, so much of the practice happens inside your normal work.

Stage by stage

1. What AI coding tools are good and bad at (4 hours)

How a language model writes code, hallucinations and the context window, completions, chat and agents, where AI helps and where it hurts, automation bias, and what your tool is. Milestone: a one-page note on how your tool works, three tasks you will hand to it, three you will design yourself first, and the checks you will run on anything it writes.

2. Setup and project context (5 hours)

Installing your tool, writing its instructions file, AGENTS.md for mixed teams, rules that apply to some files, keeping secrets out of reach, and pointing the tool at the right files. Milestone (Claude Code edition): a committed CLAUDE.md under 200 lines that you have tested, one scoped rule, deny rules for .env and keys, and a first task done with @ file references. Treat the instructions file like code: short, accurate and reviewed.

3. Prompting for code: small tasks, clear specs (6 hours)

Small, checkable tasks, a task spec with a definition of done, pointing at a pattern to follow, plan before code, prompt templates, saving prompts that work, and a fresh context for each task. Milestone: four prompt templates of your own (explain, bug, feature, refactor) and one multi-file change delivered from a written spec and an approved plan.

4. Reading and reviewing AI code (8 hours)

Reading every diff, a review checklist for AI code, explaining it back in your own words, catching invented and outdated APIs, spotting unrequested changes, committing in small reviewed steps, and AI review as a second pass. Milestone: your written checklist used on ten real AI changes, with a log of what it caught. If a diff is too long to read properly, the task was too big.

5. Tests first, so AI output is checked (8 hours)

Tests as the specification, red, green, refactor with an AI tool, writing the first test yourself, recognising tests that cannot fail, listing edge cases up front, and making the agent prove it. Milestone: a feature built test-first, with a deliberate break the suite catches and agent runs where you saw every test command and its output.

6. Debugging with AI (6 hours)

Reproduce, then shrink the problem, give the tool full evidence, hypotheses before fixes, symptom patches versus root causes, and using the real debugger. Milestone: three real bugs fixed with reproduction first, tested hypotheses, the debugger used at least once, and a regression test for each. Ask "what could cause this and how would I check?" far more often than "fix this".

7. Agents: multi-file changes, permissions and safety (8 hours)

How an agent works through a task, your tool's permission modes and rules, checkpoints and Git as your safety net, sandboxing and prompt injection, and MCP servers and background agents. Milestone: a deliberate permission mode, allow rules for test and lint commands, deny rules for pushes and secrets, a multi-file change on its own branch, and one rollback practised with both a checkpoint and Git.

8. Security and licences (6 hours)

What never goes into a prompt, hallucinated packages and new dependencies, insecure patterns AI repeats, scanning code and secrets automatically, and licences, data settings and AI policies. Milestone: a never-paste list, security rules in your instructions file, Gitleaks and Semgrep (or equivalents) running locally and in CI, and one AI-suggested dependency checked before installing.

9. Keeping your skills (10 hours)

Why skills fade with AI help, regular practice with AI switched off, attempting first and then comparing, using AI as a tutor, and reading docs first. Milestone: four weeks of weekly AI-off practice logged, ten problems solved attempt-first, and one fundamental topic you can explain without notes.

10. A real project shipped with an agent (20 hours)

Scoping a project you can finish, a written spec and vertical slices, CI and one pull request per slice, deploying and learning from real use, and disclosing AI use. Milestone: a small real project used by at least one real person, built in reviewed slices with CI, with honest AI disclosure in the README and a published write-up of your decisions and the bugs you caught.

Projects that fit

• AI coding agent instruction file linter, building on the setup stage
• Mutation testing bot for AI-written tests, from the tests-first stage
• Socratic AI programming tutor for university labs, from keeping your skills
• Evidence-grounded pull request review agent, an advanced take on AI review
• Dependency supply chain risk scanner, the defence against hallucinated and malicious packages

How it works on Sefism

Everything on Sefism is free to learn from, and this roadmap is currently free to add as well. The public page at Coding with AI tools shows every stage open for every tool, with its topics, milestones and recommended material.

Adding it to your dashboard costs no credits and does not use up your free first roadmap, so that stays available for another one. Once you add it, it stays yours. On your dashboard you can:

• tick stages off and track your progress, at a pace set by the hours you have each week
• keep the companion Coding with AI tools cheat sheet, which comes with the roadmap
• ask Tauseef a question about any stage, or book a 1:1 session if you want to talk your plan through

If you are new, create a free account first.

The companion cheat sheet

The Coding with AI tools cheat sheet follows the same ten chapters in the same three tool editions. Use it to look up a command or setting, and to check your habits before you trust a change.

Related on Sefism

• How to check if AI-generated code is correct
• Am I learning if I do not understand AI-generated code?
• Can I use AI coding tools at my internship?
• Is it bad to rely on ChatGPT or Cursor to write code?
• How to use AI as a companion, not a crutch
• Six ways to structure work for an AI agent
• Claude Code Documentation, AGENTS.md and the OpenSSF guide to AI code assistant instructions

What you can do afterwards

Direct an AI coding tool rather than be directed by it: hand it well-specified work, verify what comes back with tests and review, keep it inside safe permissions, and still be able to do the work yourself. The final project and write-up are evidence of that judgement.

Frequently asked questions

Will AI coding tools make my skills worse? They can, which is why stage 9 exists. The roadmap's answer is weekly AI-off practice, attempting before comparing, and using the tool as a tutor rather than an answer machine.

Claude Code, Cursor or GitHub Copilot: which should I follow? The one you already use, or the one your team or university provides. The habits are the same; only setup and controls differ.

How long does it take? About 81 hours: roughly 11 weeks at 10 to 12 hours a week, or 20 at 5.

Is vibe coding enough to get a job? The roadmap is built on the opposite idea: if you cannot explain a line, do not merge it. Stage 10's write-up exists to show the judgement behind the code.