You Just Became a Manager of AI Agents (and the Communication Chain is Broken)

Rebuilding context transmission across two layers of abstraction.

When you become a manager for the first time, it feels like doing open-heart surgery with oven mitts on.

You've spent years building muscle memory for the actual work. Now you're guiding someone else through it. Imprecise, frustrating, but ultimately more impactful because you're multiplying output across a team.

Managing managers is like adding dishwashing gloves inside those oven mitts. Another layer of abstraction from the hands-on work. A whole new communication skill set.

AI coding agents added another abstraction. The meme says everyone became a manager overnight. We prompt, they execute, we guide. Partially true, but the core challenge is not the prompt. It is the communication chain that got severed.

The Fundamental Difference

There's a fundamental difference in AI coding though: the communication chain is broken.

In traditional product development, PMs communicate and seek out context. User needs, tradeoffs, why we're building something. Engineers use that context to build.

With AI coding agents, the PM does not talk to the agent. The engineer becomes the single conduit. The agent cannot raise its hand and ask about users or strategy. It executes whatever fits the prompt and the code it can see. The context that used to travel directly from PM to engineer now takes an extra hop through an interface that compresses everything into text.

So agents drift off course. They build for the wrong user. They ignore long-held decisions. Engineers get frustrated by rework. PMs feel cut out of the loop. The product quality drops while the activity level rises.

The agent is not your IC. The agent is your IC's IC. You are managing through two layers with none of the usual communication bandwidth. That is why it feels like oven mitts over dishwashing gloves.

Where the chain snaps

Three places keep showing up.

1) Context intake: PM intent is expressed to an engineer in a meeting or a doc. The engineer distills it into a prompt. Nuance drops. The agent sees only the distilled version.

2) Clarification: A human engineer would ping the PM for missing details. The agent does not. It hallucinates the missing part or picks the most common pattern in the repo. Wrong defaults ship fast.

3) Feedback: The agent does not learn from implied feedback. If the engineer quietly fixes tone or rewrites a flow, the agent never sees the correction. It repeats the mistake in the next task.

Break any one of these and the loop slows. Break all three and you are paying for speed while buying rework.

The consequences in real teams

Tone and audience drift: A fintech agent ships playful microcopy into payout flows because it saw it in a marketing component. The PM intent around trust and sobriety never reached the agent. Support tickets spike. The team rewrites copy and removes confetti from error states.

Stack drift: One task introduces Fetch with hand-rolled retries. The next introduces Axios. The next pulls in a GraphQL client because it saw the schema file. The agent optimizes locally for the prompt and code around it, not for team-level consistency. The build grows brittle and hard to maintain.

Scope inversion: A customer request for “a CSV export of invoices” turns into a whole reporting UI because the agent saw a dashboard component. Meanwhile the real need was a one-click export with the right schema and audit logging. The agent filled in the gaps with patterns, not intent.

Access control misses: A B2B team asks for “admin-only feature flags.” The agent implements toggles but forgets role checks on the API. A customer with the right URL accesses the feature. The PM assumed “admin-only” implied back-end enforcement. The agent assumed UI gating was enough.

All of this looks like edge cases until you notice the pattern. The missing factor is always context transmission and verification.

Why manager instincts fail here

Managers fix communication gaps by coaching, shadowing, and quick taps. None of that reaches the agent by default. You cannot shoulder tap the model. You cannot rely on “I’ll see it in the PR” when the agent generates the PR. You cannot wait for a weekly sync to realign because the agent has already shipped three features since then.

The usual playbook—longer specs, more acceptance criteria, more review—adds ceremony but not comprehension. Agents do not parse nuance from prose. Humans do, and they still struggle with walls of text. The engineer is forced to act as interpreter and gatekeeper, which defeats the point of the agent’s speed.

The missing piece

The missing piece is not better code generation. It is giving agents the same context that makes human engineers effective: user needs, business constraints, technical decisions, and the why behind those decisions. Then making that context available at generation time and at review time, and making sure corrections flow back into the system.

What manager of managers looks like in agent world

Your job is to set intent, boundaries, and feedback loops that survive two hops.

Intent: What problem are we solving, for whom, and why now.

Boundaries: What choices are fixed. What choices are flexible. What quality bar applies to this task.

Feedback: How the agent learns from corrections and how those corrections become constraints for the next task.

Do that well and the agent feels like a senior IC. Do it poorly and the agent feels like an eager intern who never listens.

Anti-patterns to watch

Boilerplate prompts: Copying a giant prompt template into every task. It lulls you into thinking the agent “knows” things it never reads. The context needs to be short, current, and relevant to the task.

Shadow rewriting: Engineers quietly rewrite agent output without updating the shared constraints. The agent repeats the same mistake in the next task. Rework becomes permanent.

Dependency sprawl: Agents import new libraries to solve local tasks because team standards are not enforced in context. Every feature brings a new stack fragment.

Feature factory autopilot: PMs stay out of the loop until sprint review. The agent ships fast but off-target. The team backfills context after the fact.

Prompt bloat: Engineers paste entire specs, tickets, and wikis into prompts. The agent chokes on noise and still misses the key decisions.

A playbook that rebuilds the chain

1) Make decisions first-class

• Capture them in a structured format: “We use Jest,” “We never store PII in logs,” “Enterprise flows use email for critical alerts,” “Tone is concise and confident.”
• Version them. Retire stale ones. Highlight new ones to the agent and the team.
• Feed them automatically with every agent task. No copy-paste.

2) Create task-specific briefs

• One tight brief per task: goal, user, constraints, success criteria, known decisions that apply, red lines not to cross.
• Keep it short enough that a human can read in one minute and an agent can process without getting lost.
• Include rationale when a choice looks arbitrary: “Email, not in-app, because audit retention is required.”

3) Establish clarification hooks

• Give the agent a way to surface uncertainty. If a pattern deviates from decisions, the agent should ask or flag.
• For humans pairing with the agent, set a rule: if you add more than two ad hoc clarifications while editing, add them to the decision set or the brief so the next run knows them.

4) Close the feedback loop

• When you edit agent output, mark what changed and why. Was it tone, dependency choice, performance, accessibility, security, UX polish.
• Update decisions when the edit reflects a recurring pattern, not a one-off.
• Track repetition. If the agent keeps missing the same constraint, your context distribution is broken.

5) Instrument everything

• Drift events: count when the agent proposes something outside decisions.
• Rework causes: tag edits by category: context missing, decision violation, quality bar missed, ambiguity in goal.
• Time to clarity: measure from task creation to “agent has the right constraints.”
• Prompt size: watch for bloat. If briefs get long, split work or tighten decisions.

6) Keep humans in the loop without slowing them down

• PMs should see the briefs and decisions the agent uses. That visibility restores influence without calendar bloat.
• Engineers should not need to become context librarians. Automate the injection of decisions and briefs into the agent.

A concrete example: role-based access

Goal: add an “Edit Billing” screen for admins only.

Brief: who the user is (admins at enterprise customers), why it matters (billing errors cause churn), constraints (RBAC enforced server-side, no playful tone, log all changes, latency target under 300ms P95), decisions (use existing form components, use Jest, React Query, REST only, no new dependencies).

Agent run without context: builds a React form with client-side checks, uses a new HTTP client for convenience, adds a toast with a celebratory icon on success, no audit log. Looks good in a PR, fails the business intent.

Agent run with context: enforces RBAC on the API, reuses existing components, writes to the audit log, keeps tone neutral, uses existing HTTP patterns. The PR lands mostly clean. Edits focus on copy and edge cases, not on re-architecture.

The difference is not the model; it is the context and boundaries.

How to roll this out

Week 1: Build a decision register. Start with ten to twenty items that impact current work: stack choices, tone, compliance, logging, performance, dependencies. Keep it in a format agents can read.

Week 2: Create a brief template. One page, max. Fields: goal, user, rationale, constraints, success criteria, linked decisions. Use it for two active tasks. Tune it until it reads fast.

Week 3: Wire briefs and decisions into the agent workflow. Automate inclusion. Stop pasting.

Week 4: Add drift tracking and rework tagging. Make it easy to mark why you edited the agent output. Summarize weekly.

Week 5: Add a ten-minute daily decision review. Add new decisions, retire stale ones, highlight what changed.

Week 6: Give PMs and designers access to the briefs and decisions. Let them update tone, user constraints, and non-functional requirements without waiting for a sprint change.

Signals you are fixing the chain

• Agent output needs fewer rewrites for tone, dependencies, and compliance.
• Prompts get shorter because decisions carry the defaults.
• Features ship with consistent patterns across tasks.
• PMs give feedback earlier because they see what context the agent is using.
• Drift events decline week over week.
• QA finds fewer repeats of the same class of bugs.

Signals you are still broken

• Engineers keep pasting giant specs into prompts.
• The agent introduces new libraries on routine tasks.
• PMs only see work at sprint review.
• The same tone or compliance issues appear in every PR.
• Decisions live in a doc nobody updates.

The real job now

Managing an agent is not about clever prompts. It is about rebuilding a communication chain that lost a layer. The agent cannot overhear the sales call. It cannot tap the PM on the shoulder. It cannot guess which decisions are sacred. It will fill gaps with whatever patterns it sees.

You are now the manager of a manager you cannot talk to directly. Your tools are explicit decisions, tight briefs, fast feedback, and visibility. Do that and the agent becomes an extension of your product intent instead of a risk multiplier.

When people say AI has turned everyone into a manager, this is the work they are pointing at. Not status updates. Not more meetings. The work is designing the context path so the agent ships the right thing fast.