AI-Assisted Development

Your tool cannot see your repo, your screen, or yesterday's session. It sees a window of text, and everything outside that window does not exist.

Invented methods, imaginary config flags, version numbers from nowhere. Hallucination is not a glitch to wait out; it is built into how the tools work.

Not paranoia, not blind trust: calibration. The posture that turns everything from this module into a daily working practice.

"Make a login page" has a hundred valid interpretations, and the tool will pick one for you. Learn the four-part anatomy of a request it cannot misread.

Unconstrained, the tool defaults to the training data's favorite stack, style, and assumptions. Constraints are how your project's reality wins.

One input/output pair can settle five ambiguities that a paragraph of prose leaves open. The tightest specs are not descriptions; they are demonstrations.

A perfect spec for a huge task still produces an unreviewable mountain of code. Task sizing is the skill that keeps you in the sign-off seat.

The first draft is a first draft. Surgical corrections, drift patrol, and the underrated power move of starting a fresh thread.

One sentence turns the tool's hidden assumptions into a reviewable artifact before any code exists. Plan review is the cheapest bug you will ever catch.

So many bad AI answers are answers to a different codebase: the one the tool can actually see. Learn the exact visibility rules for each mode.

Your repo is a million tokens; the window is not. Retrieval decides which fragments the tool sees, and you can overrule it with one habit.

Pasting everything is as bad as pasting nothing. The skill is minimal sufficient context: exactly what the task needs, and not one file more.

Two hours into a great session, the answers quietly turn strange. Nothing broke. Your context spoiled, and there is a clean fix.

Tired of telling every new session the same five rules? Write them down once, in the file your tool reads at the start of every session.

The window is finite and every token is billed. Learn what to trim first, when to send a diff instead of a file, and when a summary beats the source.

The most dangerous moment in AI-assisted development is the second before you hit accept. This lesson installs the discipline that makes it safe.

Senior reviewers do not read every line equally. Learn the two-pass read: skim the shape, then interrogate the handful of lines where bugs actually live.

The hardest bug to catch is code with no bug in it: a clean, correct solution to a problem adjacent to yours. Learn to review against the spec, not the code.

You asked for one small change. The diff touches four files. Learn to read AI diffs for the three classic smuggled surprises: deletions, scope creep, and unasked improvements.

When generated code doesn't look like YOUR code, that mismatch is information. Learn which style deviations are cosmetic and which ones mean the tool never saw your codebase.

Asking the AI to explain its code is a genuinely powerful review tool, with one catch: models defend their own bugs. Learn to use explanations without being used by them.

Your assistant will invent methods that look exactly like the real thing. Learn to spot the confident call that does not exist.

Every API is real, every line runs, and the answer is wrong at exactly the inputs that matter. Meet the off-by-one and its cousins.

AI code is written for the demo input. Empty lists, missing keys, and malformed strings are where it quietly falls over.

The internet taught your assistant twenty years of insecure tutorial code, and it will happily reproduce all of it. SQL injection, XSS, and weak hashing on parade.

Your assistant learned to code from a snapshot of the past, and the past had more examples. Spot the deprecated idiom wearing a confident face.

The model will explain its own buggy code beautifully, and the explanation will be wrong. When story and runtime disagree, the runtime wins.

Sometimes the hallucination is an entire dependency, and sometimes an attacker registered it first. The install command is a trust decision.

"It compiles and looks right" is not verification. Meet the ladder from reading to proving, and learn which rung each task deserves.

A test is an executable clause of your spec. Write it from the spec, and it catches the bug; write it from the code, and it enshrines the bug.

A green test suite feels like proof. AI-written tests can assert the bug, assert nothing, or mock away the very thing being tested.

Zero, one, many, weird: the boundary enumeration that finds the inputs AI code was never written for.

Failing test first, then the fix, then green, then the diff. The step everyone skips is the one that makes the loop work.

The change works. But who else calls that function, reads that field, depends on that format? The last review question before shipping.

"It doesn't work" gets you a shrug from humans and a guess from machines. A debuggable report gets you a diagnosis.

The model is a phenomenal generator of suspects and a mediocre judge of guilt. Let it brainstorm causes; you run the experiments.

Every developer has fed "still broken" to an assistant six times in a row. Learn the loop signatures, and the three exits.

Sometimes the best use of a code-writing machine is to make it stop writing code. Explain your work to it, and demand critique instead of rewrites.

"Clean this up" is the most dangerous prompt in the book, because the diff looks better and behaves differently. Tests first, small steps, one change at a time.

AI turns "what does this 400-line function even do" from an afternoon into ten minutes. Unless its story is confidently wrong, and you build on it.

Chat suggests; an agent acts. It reads your files, edits them, runs commands, and loops on the results. New power, and a genuinely new failure surface.

A flawed step caught in the plan costs one sentence to fix. The same flaw caught in the diff costs an afternoon. Plans are the cheapest review you will ever do.

Interrupting an agent is not rude, it is management. But vague feedback produces vague corrections, and "that's wrong" is the vaguest sentence in engineering.

An agent mistake is cheap or catastrophic depending on one thing: how far back your last known-good state is. Git is the undo button; commits are where you place it.

Agents fail politely: the transcript keeps scrolling, the tone stays confident, and step 5 quietly edits the test to match the bug. Learn the signals that mean intervene NOW.

The senior move is not typing faster than the agent. It is knowing which phases of a feature to delegate and which decisions must never leave your desk.

Everything you paste into a prompt leaves your machine. Learn what must never make the trip, and what to do the second a secret slips through.

Generated code can arrive with strings attached. Training data includes licensed code, and sometimes the output matches it closely enough to matter.

The same model behind a consumer app and an enterprise contract handles your data under completely different rules. Knowing which rules apply to you is part of the job.

Your agent reads READMEs, issues, and dependency code, and it tends to do what text tells it. Attackers have started writing text for exactly that audience.

The strongest tool users are defined by what they refuse to delegate. Three buckets, two questions, and the cases where the answer is your own hands.

Two students, the same tool, opposite outcomes. The difference is whether the AI is a tutor or an answer vending machine, and you choose which one it is.

Skill atrophy is gradual, comfortable, and invisible until the day it isn't. An honest self-audit, and the practice habits that keep your review skills real.

Two AI solutions, both working, one clearly better. Before the capstone build, you need the criteria that separate them, because "it runs" is the floor, not the ceiling.

The capstone feature gets its spec: a CSV import endpoint, written the way Module 2 taught. Every decision made here becomes the measuring stick for the build and the verification.

The agent's plan looks right and its diffs read fluently. Three real defects are hiding in them, one per diff, and your review is the last gate before production.

The defects are fixed; now prove it. Tests chosen from the spec, an AI-written test that must be rejected, a blast-radius surprise, and the signoff that puts your name on it.

The course ends where careers begin: director, reviewer, verifier as an identity that outlasts every tool it will ever be practiced on.