The arc — and where to go next

That’s the course. Before you close it, look back at the shape of what you did, because the shape is the actual lesson — not any one feature you learned to drive.

The arc, in one breath

You joined a new squad and inherited two repos you didn’t write. Your first real piece of work — an approval workflow for orders-service — turned out to need a change to shared-lib first, a library a dozen other services lean on. So the job split into two halves with opposite risk, and the whole course was you learning to feel that difference and respond to it.

You shipped a first tiny reviewed change before anything was at stake, so you’d run the loop once — describe, read the diff, commit — with nothing on the line. Then you met the four modes and the judgment they exist to serve: Ask to understand, Edit to scope, Agent to hand off, Plan to gate the risky work. When Copilot’s first drafts kept missing how each repo does things, you stopped correcting by hand and wrote the conventions down once — the copilot-instructions.md, the AGENTS.md — so its code arrived already passing review. You codified a repeated team task as a prompt file, built a library-reviewer custom agent and fanned subagents across the twelve consumers, packaged the audit-event convention as a portable skill, and reached an internal service registry over MCP to find who’d break.

Then the trust dials. You tightened approvals to a short leash on the library and loosened them on the app, spent higher reasoning where the work was genuinely hard and routine reasoning where it wasn’t, and handed a backlog of follow-ups to the cloud coding agent — issues assigned, draft PRs returned, never a push to main. You confirmed almost none of it was tied to VS Code. And in the last lesson you watched all of it run together across a single day, the choices gone quiet.

The one thing to keep

If you forget every file path and setting name in this course, keep this:

Match autonomy to blast radius, not difficulty.

That’s the spine the whole thing hangs on. The mode you reach for, how much you let the agent run, how hard you make it think — none of those are set by how hard the task is. They’re set by how much a wrong answer costs and how hard it is to undo. A gnarly algorithm alone in a file you own is hard but cheap to get wrong — long leash. A one-line signature tweak to a library a dozen services import is easy but expensive — short leash. The whole course gave you two repos for exactly this reason: same engineer, same feature, opposite postures, set by what was at stake and nothing else. Hold onto that and the specific buttons take care of themselves.

Why the work travels

Here’s the part that pays off beyond Copilot. The most valuable thing you produced in this course wasn’t any diff — it was the context you wrote down: the conventions in AGENTS.md, the audit convention in a SKILL.md. And that context isn’t editor-shaped. It’s repo-shaped.

That’s the bridge. The same AGENTS.md Copilot read on every request is read by JetBrains, by the cloud coding agent, and — this is the real payoff — by your other agents. If you also run Claude Code or Codex, they read the same rules files and the same skills standard. You didn’t write conventions for Copilot. You wrote them for the repo, once, and every capable agent you point at that repo inherits them. Closing the context gap compounds across every tool you use, instead of being a tax you re-pay per editor.

Where to go from here

For the spec-level other half — Foundations. This course was a story: two repos, one feature, each primitive introduced exactly when the work demanded it. That’s how you build the instinct, but it stayed deliberately light on the exhaustive “here is this primitive and every option it takes” view. Foundations is that view — lookup-shaped and authoritative, the place to go when you need the full precedence rules for custom instructions or every field a custom agent accepts, rather than the slice the story needed. Same picture from the other side: this course taught the practice, Foundations is the reference.

For your other tools — the sibling courses. Most engineers don’t live in one agent, and what you just built carries. The Claude Code course and the Codex course run on this same teach-by-doing spine — one project, the primitives introduced as the work needs them — told in each tool’s idiom. And the rules and skills you wrote here come with you: pick up either course already knowing that the context work transfers, because it does. The primitives are universal even when every tool spells them a little differently. Learn the discipline once; carry it across all of them.

The whole job

Strip the tool away and every chapter taught one thing. Copilot is extraordinary at the general — broad, fast, fluent across languages — and blind to the particular: it doesn’t know your codebase, your team’s conventions, or that shared-lib has twelve consumers who’ll feel a careless change. You’re the inverse: slower, narrower, but you know all of that cold. Every move in this course was a way to hand the agent the context it was missing, and a way to decide how far to trust it once it had that context.

That’s the discipline. Not a clever prompt, not a favorite mode — closing the gap between what you know and what the agent knows, and matching the leash to what’s at stake, on purpose, every time. You have the habit now. Go use it.