A day — careful lib, fast app

Here’s a day on the Platform squad — the same two repos you’ve worked all course, shared-lib and orders-service, and the same single engineer moving between them. Nothing in it is new. That’s the point. Every move below came from an earlier chapter; what this lesson shows is the choosing — how you pick surface, mode, permission, and reasoning to fit what’s actually in front of you, dozens of times a day, mostly without stopping to name the choice.

We’ll narrate the day slowly anyway, surfacing each decision, because the whole skill is in decisions that have become invisible.

Morning — the shared-lib change, on a short leash

A bug report is waiting when you sit down: a downstream service is getting the wrong audit event when an approval is granted. The fix lives in shared-lib. You feel the posture shift before you’ve read a line of code — because this is the library a dozen services import, and a wrong answer here doesn’t hurt you, it hurts twelve teams you’ll never meet. High blast radius. Short leash. None of that is a decision you deliberate; it’s the reflex the course was built to install.

So you don’t open Agent mode and turn it loose. You start in Ask, because you didn’t write this audit helper and you’re not going to edit code you don’t yet understand. You ask Copilot to walk you through how the event types are constructed and where the granted-event path diverges from the requested-event path. It makes no changes — Ask never does — and you read until the shape of the bug is clear.

Now you understand it, but you still don’t trust the approach blind, because it’s a library change. So you climb one rung to Plan: you ask for the step-by-step before any code exists. The plan comes back, you read it the way you’d read a diff, and you catch that it proposed touching a second event type you didn’t want disturbed. You say so, the plan narrows, and only then does code get written. Notice the order — understand, agree the approach, then build — and notice it cost you nothing to climb, because switching modes carries the whole conversation forward into the next.

The build itself goes through your library-reviewer custom agent — the persona you wrote back in the custom-agents chapter, the one that knows this repo’s conventions and is wired to be skeptical of breaking changes. Before you accept anything, you let its subagents fan out across the consumers, using the MCP connection to your service registry to find which of the twelve actually call the changed path. Three do. You read the agent’s report on each.

Permissions stay at Default the whole morning — only the read-only, safe tools auto-approve; anything that touches the world waits for you. When the agent wants to run the consumer test suites, each command surfaces for your explicit yes. That friction is the feature here, not an annoyance to route around. And because the reasoning is genuinely hard — you’re checking a change against a dozen call sites — you spend the credits on higher reasoning without a second thought. This is exactly the work that’s worth it.

By late morning the change is in a reviewed PR, the three affected consumers are confirmed green, and you’ve touched the keyboard for every decision that mattered. Slow on purpose. That’s what high blast radius buys.

Afternoon — the orders-service feature, on a long leash

After lunch the work changes shape completely, and so does your posture. There’s a feature to build in orders-service — the approval-workflow surface that sits on top of the library change you just shipped — plus a short backlog of follow-ups: a couple of validation edge cases, an audit-report endpoint nobody’s gotten to.

This is your squad’s own app. You own it, the tests are fast, and anything that goes wrong you can fix forward in an hour. Low blast radius. Long leash. The dial swings the other way, and again you don’t deliberate it — the same instinct that tightened you up this morning loosens you now.

So the feature goes straight to Agent mode. You give it the goal, not a file list: build the approval-workflow endpoint on the new shared-lib version, wire it to the audit events, cover it with tests. It plans, edits across however many files it decides it needs, runs the suite, self-corrects when something fails, and checks in at the milestones. You loosen permissions to match — you let it run the local test loop without approving each command, because on this repo a bad command is cheap and the round-trips would just slow you down. You review the whole diff at the end, as one piece, instead of gating it move by move. Reasoning drops to routine here, too: this is CRUD against a shape you already designed in the morning, not a puzzle. No reason to pay top rate for it.

The backlog is where the leash goes longest of all. You don’t build those follow-ups yourself — you don’t even keep them in front of you. You assign each one to the cloud coding agent: an issue handed off, or an @copilot mention on a PR. It picks the work up in its own ephemeral environment, reads the same rules files your local Copilot reads, and comes back with draft PRs — never a push to main, always something you review. While it grinds through the validation edge cases, you’re back in the editor finishing the feature. You’re running two streams at once: you on the thing that needs you, the cloud agent on the things that don’t.

By end of day the feature’s in review and two of the three backlog issues are sitting as draft PRs waiting for your eyes tomorrow. Fast on purpose. That’s what low blast radius buys.

The whole day was one judgment

Lay the morning and the afternoon side by side and the symmetry is the lesson. Same engineer, same week, same loop underneath — describe, review, decide. What flipped, every time, was the leash:

• Morning, shared-lib: Ask, then Plan, the library-reviewer agent, subagent fan-out, Default permissions with every command reviewed, higher reasoning. Short leash, because twelve teams pay for a mistake.
• Afternoon, orders-service: Agent mode, loosened permissions, the cloud agent on the backlog, routine reasoning, review at the end. Long leash, because only you pay, and you pay cheaply.

You didn’t consult a chart to make any of those calls. By now you read a task and the posture arrives — which surface, which mode, how much it can run, how hard it should think — the way you read a road and your hands find the gear. That fluency, not any one of the moves, is what the course was for. The last lesson is about what it leaves you with.