AI-Assisted Development
by Sergey Okinchuk
Ch. 1

AI-Assisted Development

Welcome

Coding agents now write a large share of the code that ships, and the gap between a team that uses them well and one that vibe-codes its way into a codebase nobody understands is the gap between engineering and gambling. This course teaches the professional practice: the agent writes the code, and you remain its author.

15 chapters 76 topics covered Knowledge check on every topic Every example in Python, TypeScript or Java ≈17.5 hours to complete

About This Course

Everything a coding agent produces arrives as a proposal against a repository you are accountable for. It can read your code, edit a dozen files, run the tests and report success in a few minutes, and none of that changes who answers for the change when it reaches production. Every habit in this book follows from that one fact: give the agent the context a new colleague would need, ask for a change small enough to read, read every diff, let tests decide what "works" means, commit before you ask so any answer can be thrown away, and never hand it more access than the task needs.

The book moves in five parts. First, what the tool actually is and the antipattern it invites: vibe coding, defined precisely, and the week it stops working. Then the setup before a prompt: the repository, the context the agent sees and the task you give it. Then the discipline after it: reading the diff, the characteristic ways AI code goes wrong, tests as the contract and git as the undo button. Then real work: debugging, unfamiliar legacy code, security and the team. Last, an honest accounting of what it costs, what the evidence says it saves and what it does to your own skills, followed by the real tools of the moment in one chapter of their own.

Every example comes from one codebase. Cragmoor runs four indoor climbing gyms, and its three-year-old booking service, about 60,000 lines written by people who have since left, is the code you have just inherited. Its rules fit in a sentence each: a class of 16, a 15-minute hold on a waitlist offer, a full refund up to 24 hours before the class. Every one of them has an edge an agent can get wrong. Your first task, cutting the refund window to 12 hours, runs from specification to commit across Chapters 3 to 9.

Who This Is For

Programmers early in their careers, or experienced programmers new to coding agents. The bar is concrete: you read and write small programs in one language, you have run a test suite, and you use git for commits, branches, merges and reverts. You have used a chat assistant, and you may have accepted code from one without reading it. By the end you will work with a coding agent on a real codebase the way a careful engineer does, and be able to say why each habit exists.

It is not a course on how agents are built; that is Agentic AI from Scratch. It does not teach a programming language, compare models or rank tools, and it teaches no prompt tricks. It is vendor-neutral throughout: Chapters 1 to 14 describe what agents in general do, and the products of the moment, with their setup and prices, live in Chapter 15, which is rewritten as the market moves.

What You Should Already Know

  • Reading and writing small programs in Python, TypeScript or Java: functions, conditions, loops and a module or two
  • Running a test suite and reading what a failing test prints, at the level of QA & Software Testing for Beginners
  • Git for everyday work, commit, branch, merge and revert, at the level of Git for Beginners
  • What a language model is and what a context window means, at the level of Working with LLMs from Zero

New to this? Start with Working with LLMs from Zero and Git for Beginners - the first chapter of every course is free, and the rest is one membership.

How the Course Is Built

Every topic has the same shape: an opening that says what the idea is and why it matters, the mechanism explained in plain words with a figure and a Cragmoor case, the misconceptions working programmers actually hold about it, what to do about it, and a short knowledge check. Agent sessions appear as short transcripts, and the prose around each one says what happened, so the page reads the same whether or not you study the transcript.

Pick Python, TypeScript or Java once, with the tab on any code block, and every snippet, diff and test run in the book switches to that language. The prose is the same for every reader and never depends on which you chose: it says "the test runner" and "the type checker", and the code shows you yours. Code samples are written for current versions of each language and its test runner, and where a page shows output, it is what those versions printed.

You remain the author
The agent types; you answer for every line. Accountability never moves to a tool, so every habit in the book is a clause of one contract: read it, test it, and be able to explain it.
Trust is earned by evidence
Neither oracle nor toy. A failing test that now passes and a diff you understood count as evidence; the agent's own summary, however fluent, does not.
One loop, every chapter
Specify, context, generate, read, test, commit or discard. Chapter 2 introduces it, and every chapter after is one stage of it done properly.
No hype, no doom
Claims about productivity cite the studies and their limits. Moving capabilities are dated, and tool names stay in the one chapter built to be rewritten.

Chapter Map

Chapter 1
What You Are Working With
From autocomplete to agent, the loop you supervise, what the agent sees and what it can touch, where it runs, and Cragmoor's booking service with its first task.
Chapter 2
Vibe Coding and the Third Week
Vibe coding defined as accepting code you have not read, its honest uses, Kai's waitlist and its double offer, the contract of ownership, and the six-stage loop.
Chapter 3
Preparing the Repository
The project instructions file, the commands the agent needs, permissions and approval modes, sandboxes and the blast radius, and a clean starting point.
Chapter 4
Context — What the Agent Knows
Context as the interface, pointing instead of pasting, why long sessions drift, instructions that persist and rot, and what you let in from the outside world.
Chapter 5
Specifying the Task
A task an agent can finish, a plan before any code, small steps and checkpoints, examples as acceptance criteria, and when to write it yourself.
Chapter 6
Reading the Diff
The diff as the product, a reading order, the questions for every change, why explanations are not evidence, and rejecting, narrowing or redirecting a change.
Chapter 7
How AI Code Goes Wrong
Invented APIs, tests bent to pass, quiet behaviour changes, over-building, symptom fixes, and calls from yesterday's version of a library.
Chapter 8
Tests as the Contract
Why tests matter more now, test-first with an agent, reviewing tests it wrote, the edges it misses, and the fast feedback loop it can run itself.
Chapter 9
Git as the Undo Button
A commit before every request, one task per branch, throwing work away cheaply, history an agent wrote, and parallel agents in separate worktrees.
Chapter 10
Debugging With an Agent
The double waitlist offer: reproduce first, hand it the evidence, find the root cause, recognise an agent going in circles, and bisect history to the change that broke it.
Chapter 11
Unfamiliar and Legacy Code
Mapping a codebase with an agent, pinning the untested pricing module's behaviour, refactoring in safe steps, large mechanical changes, and documentation, checked.
Chapter 12
Security
Secrets out of context, instructions hidden in content, invented package names and the supply chain, insecure patterns it repeats, and least privilege for agents.
Chapter 13
Working in a Team
Reviewing an AI-assisted pull request, automated reviewers, team policy, who owns generated code, and agents that open pull requests on their own.
Chapter 14
Cost, Evidence and Your Own Skills
What it really costs, what the published studies found and their limits, keeping your own skills, and the kinds of work where the loop is the wrong tool.
Chapter 15
The Tools, as of 2026
Terminal agents, editor assistants and cloud agents of the moment, what carries over between them, how to evaluate a new one, and where to go next.

Disclaimer

This course is an independent educational project created and maintained by Sergey Okinchuk. It is provided for learning and reference purposes only.

No affiliation. This course is not affiliated with, sponsored by, endorsed by, or officially connected to any company, product, or project mentioned, including the makers of the coding assistants, models, editors and developer tools named in Chapter 15. All opinions, interpretations, and recommendations expressed are the author's own.

Trademarks. Product, language and project names referenced, including "Python", "TypeScript", "Java", "Git" and the tools named in Chapter 15, are the property of their respective owners. Use of these names is for identification and educational purposes only and does not imply any endorsement.

Not operational advice. This material teaches practices for working with coding agents, not turnkey instructions for any specific environment. Permissions, sandboxes and credentials protect real systems only when they are configured for those systems: test any setup on code and data you can afford to lose before you trust it with anything that matters.

Accuracy and currency. This is a fast-moving field. Tool-specific facts are confined to Chapter 15 and were written against the state of the market in October 2026; capabilities, defaults, file names and prices drift. Language and test-runner versions reflect the versions current at the time of writing. Always verify against the official documentation for the tools and versions you actually use.

Fictional example. Cragmoor, its booking service, its staff and every figure attributed to them are invented for teaching. Agent transcripts are illustrative reconstructions, not recordings of any particular product.

No warranty. This material is provided "as is" without warranty of any kind. The author accepts no liability for any loss or damage arising from reliance on the content.