A day - careful lib, fast app

Here is a day on one squad’s calendar - the same two repos this course has followed all along, shared-lib (the library roughly a dozen services import) and orders-service (the order app the squad owns), and one engineer moving between them. Nothing in the day is new. Every move below came from an earlier chapter; what this page shows is the choosing - how surface (your editor or the cloud agent), role, permission, and reasoning get picked to fit what is in front of you, dozens of times a day, mostly without stopping to name the choice.

The day is narrated slowly anyway, surfacing each decision, because the whole skill lives in decisions that have become invisible.

Morning - the shared-library change, on a short leash

A bug report is waiting at sit-down: a downstream service is getting the wrong audit event when an approval is granted. The fix lives in shared-lib. The posture shift happens before a line is read, because this is the library a dozen services import, and a wrong answer does not hurt you - it hurts teams you will never meet. High stakes. Short leash. That is not a deliberation; it is the reflex the course was built to install.

So the full Agent role is not turned loose. The morning starts in Ask, because this audit helper was not written by you, and code you do not yet understand does not get edited. Copilot walks through how the event types are constructed and where the granted-event path diverges from the requested-event path - changing nothing, Ask never does - until the shape of the bug is clear.

Understanding is not the same as trusting the approach, though, and on a library change the approach is the risk. So one rung up to Plan: the step-by-step before any code exists. The plan comes back, gets read the way a diff gets read, and proposes touching a second event type that should not be disturbed. Pushback, the plan narrows, and only then does code get written - by the library-reviewer custom agent, the persona that knows this repo’s additive-only rule. Before accepting anything, its subagents fan out across the consumers, using the MCP connection to the service registry to find which of the dozen actually call the changed path. Three do. Each report gets read.

Permissions stay at Manual the whole morning: consequential actions wait for an explicit yes, and when the agent wants to run the consumer test suites, each command surfaces for review. That friction is the feature, not an annoyance to route around. And because the reasoning is genuinely hard - checking a change against a dozen call sites - the morning spends credits on a stronger model without a second thought.

By late morning the change is in a reviewed PR, the three affected consumers are confirmed green, and every decision that mattered crossed a human desk. Slow on purpose. That is what high stakes buy.

Afternoon - the squad’s app, on a long leash

After lunch the work changes shape completely, and so does the posture. There is a feature to build in orders-service - the approval-workflow surface on top of the library change reviewed and merged before lunch - plus a short backlog of follow-ups: a couple of validation edge cases, a report endpoint nobody has gotten to.

This is the squad’s own app: owned, fast tests, and anything that goes wrong is a diff to revert or a fix-forward in an hour. Low stakes. Long leash. The same instinct that tightened the morning loosens the afternoon.

The feature goes straight to Agent. The request is the goal, not a file list: build the approval-workflow endpoint on the new library version, wire the audit events, cover it with tests. Copilot plans, edits across whatever files it decides it needs, runs the suite, self-corrects when something fails, and reports at the end. Permissions loosen to match - the local test loop runs without approving each command, because on this repo a bad command is cheap and the round-trips would only slow things down. The whole diff gets read at the end, as one piece, instead of being gated move by move. Reasoning drops to routine too: this is CRUD against a shape designed that morning, not a puzzle. No reason to pay top rate for it.

The backlog is where the leash goes longest of all. Those follow-ups are not built in the editor at all - they are not even kept in front of you. Each one becomes a well-written issue assigned to the cloud coding agent: it picks the work up in its own ephemeral environment, reads the same rules files the local Copilot reads, and comes back with pull requests for your review - the work lands on its own branch, and the merge waits for you. While it grinds through the edge cases, you are back in the editor finishing the feature. Two streams at once: you on the thing that needs you, the cloud agent on the things that do not.

By end of day the feature is in review and two of the three backlog issues are pull requests waiting for eyes. Fast on purpose. That is what low stakes buy.

The whole day was one judgment

Lay the morning and afternoon side by side and the symmetry is the lesson. Same engineer, same loop underneath - describe, review, decide - and the leash itself is the course’s framework in one line: a control choice, paid for in cost, informed by context, spent where capability pays. What flipped, every time, was the leash:

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

Try it

Plan your next work session around the decision path: start in Ask on a problem you did not write, keep a contained fix scoped to named files, step up to Plan when the approach itself is the risk, and reach the full Agent handoff when the change genuinely spans files. Note which role you would have defaulted to before this course - that reflex is what the chapters were retraining.

No chart was consulted to make any of those calls. By now you read a task and the posture arrives - which surface, which role, 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 move, is what the course was for. Next: the arc, and where to go next.