Collaboration Patterns for AI-Augmented Teams
- Home /
- Collaboration Patterns for AI-Augmented Teams
Most advice about AI in software development is about the individual: how you prompt better, how you ship faster. This is the other half — what a team does differently, together, when everyone has an agent.
Each pattern answers one question: what does the team do differently together because of AI? They’re grouped by the phase of the team’s work loop, from the operating stance above it down through planning, building, integrating, and learning.
This is an early draft, published for feedback. If something rings true, or false, tell me.
Team stance
The operating model above the loop.
Plan together, work alone
Agree on impact and direction once, so everyone's agent pulls the same way.
Trap: measuring AI adoption by tokens spent
Tokens burned is an activity metric pretending to be a value metric. Don't run the team on it.
Apply AI across the whole value stream
Point AI at the actual bottleneck — not just the coding, because coding was rarely the slow part.
Reshape roles — drop the silos
"I'm just the backend Java dev" is a luxury the team can't afford anymore.
Plan together
Aligning before the work splits.
Agent backlog analysis
Use the agent to make refinement teach more — not to pre-write the answers.
Executable specs
Specs the team can run — one artifact that pins down "done," guards every future change, and talks to the business.
Prototype, then bring it to refinement
Don't argue about the abstract — have an agent build the cheap version and refine that.
Frequent business sync
When engineering moves at AI speed, a two-week feedback loop starves the team of decisions. The business must sync with tech daily.
Build in flow
Keeping speed and the codebase healthy.
Cleanup time after agents
Budget the team's time to tidy what agents leave behind — or the mess compounds into everyone's.
Consistent, excellent codebase
AI copies whatever it sees — so every deviation from the team's standard breeds more of itself.
Deterministic guardrails
Over time, move more and more checks to deterministic steps rather than relying on AI reasoning.
Product observability
Make what's really happening in production visible to the whole team — and to their agents.
Shorter iterations
Integrate in hours, not weeks — agents make big batches cheap to produce and brutal to merge.
Integrate & review
Bringing parallel work back together.
Visualize code changes for review
Ask the LLM to visualize a code change to make the review process easier.
Gap analysis: prototype vs. product
Name the distance between "it demos" and "it ships" — together, before someone assumes it's done.
Trunk-based development to handle review volume
Move to trunk-based development to handle the increased volume of AI-assisted code reviews.
Learn & remember
The team's shared brain.
ADRs — record the why
Capture the reasoning behind a decision, so the team and its agents stop re-litigating it.
Sprint review format
Review what compounds — product, skills, architecture, key changes — not how much code got finished.
Agent-written shared docs
Feed an agent the code and a recorded conversation; let it write the docs nobody has time to.
Compact temporary docs
Agentic workflows breed a design doc per feature. Periodically fold them into one truth and delete the rest.
Current-architecture workshop
Get everyone the same picture of the system as it is now — first to bootstrap the docs agents lean on, then to keep them honest.
Product memory
A durable, shared store of how the product works — the context agents read in before they act.
Skill sharing
Package a hard-won way of working so the whole team — and their agents — inherit it for free.