team-topologies
Organize business and technology teams for fast flow using Skelton & Pais''s "Team Topologies"
Install / Use
npx skills add wondelai/skills --skill team-topologiesInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
Development & EngineeringSupported Platforms
Our assessment of team-topologies
team-topologies scores 84/100 on our quality scale, 2883rd of 4,698 Development & Engineering skills we index.
Its SKILL.md is 18 KB long, well organised into 14 sections and no code examples: a thorough specification that gives an agent plenty to work with.
With 2,248 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 2 months ago, so team-topologies is actively maintained.
- Our last check on 2026-11-05 found the source still online.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-01. Automated pattern scan on 2026-10-01. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
team-topologies compared with similar skills
All 4 of these similar skills score higher than team-topologies; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| team-topologies (this skill)by wondelai | 84 | 2.2k | 2mo ago | SKILL.md |
| taste-skillby Leonxlnx | 100 | 116.8k | 8d ago | CLAUDE.md |
| ai-job-searchby ai-job-search-dev | 100 | 72.1k | today | CLAUDE.md |
| claude-howtoby luongnv89 | 100 | 47.3k | 2d ago | CLAUDE.md |
| Claude-Code-Game-Studiosby Donchitos | 100 | 39.7k | 7d ago | CLAUDE.md |
Frequently asked questions
- How do I install team-topologies?
- Run
npx skills add wondelai/skills --skill team-topologies. The install tabs above show the steps for each supported agent. - Which AI agents does team-topologies work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is team-topologies safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is team-topologies still maintained?
- The repository was last updated about 2 months ago, so team-topologies is actively maintained.
Skill content
View source on GitHubname: team-topologies description: 'Organize business and technology teams for fast flow using Skelton & Pais''s "Team Topologies". Use when the user mentions "team topologies", "Conway''s law", "platform team", "stream-aligned team", "team boundaries", "cognitive load", "how should we split teams", "who owns this service", "team dependencies", or "reorg". Also trigger when reorganizing engineering teams, aligning team and service boundaries, splitting a monolith and deciding ownership, reducing cross-team handoffs, or designing an internal platform. Covers the four team types, three interaction modes, the inverse Conway maneuver, and fracture planes. For bounded contexts, see domain-driven-design. For dependency direction in code, see clean-architecture.' license: MIT metadata: author: wondelai version: "1.2.0"
Team Topologies
A team-first approach to organization design from Matthew Skelton and Manuel Pais's Team Topologies: four fundamental team types, three interaction modes, and deliberate attention to Conway's law and team cognitive load. Use it to structure engineering organizations for fast flow of change — and to keep evolving them as the system, technology, and market shift.
Core Principle
The team is the unit of delivery, and organizations ship their communication structure. Conway's law guarantees that system architecture mirrors how teams actually communicate, so team boundaries and interactions must be designed as deliberately as the software itself. Size each team's responsibilities to its cognitive load, align most teams to streams of business change, declare how teams interact, and treat the resulting topology as a living architecture decision that optimizes for fast flow.
Scoring
Goal: 10/10. Rate org and team designs 0-10 against the principles below. Report the current score and the specific changes needed to reach 10/10.
- 9-10: Stream-aligned teams own end-to-end slices sized to cognitive load; platform, enabling, and complicated-subsystem teams exist only to reduce that load; interaction modes are explicit and evolve deliberately
- 7-8: Mostly stream-aligned with a real platform, but some shared ownership, undeclared interaction modes, or one overloaded team
- 5-6: Team types named but boundaries cut by technology layer; collaboration unbounded; platform adoption mandated
- 3-4: Component teams everywhere; ticket-driven shared services; every change crosses several teams
- 0-2: Org ignores Conway's law: project-based staffing churn, "everyone talks to everyone", no notion of cognitive load
Framework
1. Conway's Law and the Inverse Conway Maneuver
Core concept: "Any organization that designs a system will produce a design whose structure is a copy of the organization's communication structure" (Mel Conway). Org communication and system architecture are homomorphic — they mirror each other by force, not by metaphor. The inverse Conway maneuver exploits this: decide the architecture you want, then shape teams and their communication paths so that architecture becomes the natural outcome.
Why it works: Teams can only build interfaces they can coordinate, so the space of designs an org can discover is constrained by its communication paths. Reshaping the org reshapes the system; fighting Conway's law instead produces permanent friction and architecture erosion.
Key insights:
- Interfaces emerge where teams communicate; seams emerge where they don't — the system records your org's conversations
- The actual communication structure (chat, code review, meeting invites) drives architecture, not the org chart
- "Everyone talks to everyone" produces tangled systems: unconstrained communication means unconstrained coupling
- A well-designed org needs less inter-team communication, not more — broad cross-team chatter signals wrong boundaries, not healthy collaboration
- Anyone who shapes teams, reporting lines, or hiring is making architecture decisions — architects must co-design the org, and reorgs need architectural review
- When the target architecture and the team structure conflict, the team structure wins
Applications:
| Context | Application | Example | |---------|-------------|---------| | Target architecture | Shape teams first; expect the architecture to follow | Want decoupled services → small decoupled teams with independent deploys | | Reorg proposal | Review it as an architecture change | Tech lead/architect signs off on a team merge, not only HR | | Tangled system | Map actual communication, not the org chart | Chat and review graph reveals hidden coupling between "independent" teams |
2. The Four Fundamental Team Types
Core concept: Reduce every team to one of four types. Stream-aligned teams own a flow of business change end to end — the primary type, and most teams. Enabling teams grow capabilities in stream-aligned teams and then move on. Complicated-subsystem teams encapsulate deep specialist knowledge (an ML model, a codec, a pricing engine). Platform teams provide a compelling internal product that reduces stream-aligned teams' cognitive load.
Why it works: Ambiguous charters ("the API team", "the DevOps team") accumulate work that belongs nowhere and interact unpredictably. Four well-defined types make gaps and overlaps visible, give every team a clear purpose relative to the flow of change, and make the rest of the org's expectations legible.
Key insights:
- Stream-aligned is the default; the other three types are justified only by the load they remove from streams
- An enabling team that never disengages has become a dependency — measure it by capabilities transferred, not tickets closed
- Complicated-subsystem teams are justified by genuine specialism, never by managerial convenience — most orgs need zero or one
- A platform exists to remove load from streams: if adopting it is harder than self-hosting, it is a liability, not a platform
- Anti-patterns: shared-services teams become ticket-queue bottlenecks; a "DevOps team" between dev and ops adds a third silo; component teams everywhere mean every feature crosses many teams
Applications:
| Context | Application | Example | |---------|-------------|---------| | Ambiguous team charter | Force a choice among the four types | "Core services team" → platform with internal customers and SLAs | | Deep specialist capability | Complicated-subsystem behind a simple interface | Recommendation-engine team exposes a scoring API to streams | | New practice rollout | Enabling team, time-boxed | Test-automation specialists coach each stream for 8 weeks, then exit |
3. The Three Interaction Modes
Core concept: Teams interact in exactly three modes: collaboration (two teams work closely together for discovery), X-as-a-Service (one team consumes something another provides over a clear interface), and facilitating (one team helps another learn or improve). For every pair of interacting teams, choose one mode and declare it explicitly.
Why it works: Most organizational pain is an undefined interaction: a team expecting a service gets dragged into joint design; a team expecting coaching gets a ticket queue. Declared modes set mutual expectations, bound coordination cost, and turn interpersonal friction into a usable design signal.
Key insights:
- Collaboration is for discovery and is expensive — it blurs boundaries and raises both teams' cognitive load; time-box it, and limit each team to one collaboration at a time
- X-as-a-Service trades discovery speed for predictability — right for established interfaces, wrong while the boundary is still unknown
- Modes should evolve deliberately: collaborate to discover an interface, then shift to X-as-a-Service as it stabilizes
- Persistent friction is organizational sensing data: awkward collaboration suggests a wrong boundary; a clunky service suggests the platform needs product work
- A temporary, declared switch back to collaboration is the standard way to adopt a major new platform capability
Applications:
| Context | Application | Example | |---------|-------------|---------| | New platform capability | Collaborate first, then X-as-a-Service | Stream and platform pair on a logging API for 6 weeks, then consume it | | Two teams in endless meetings | Declare the intended mode | Agree it is a service relationship → cut standing syncs, publish the API | | Capability gap in a stream | Facilitating engagement | Enabling team pairs on observability practices, exits within a quarter |
See: references/interaction-modes.md
4. Team Cognitive Load and Team-Sized Software
Core concept: Match responsibilities to the team's cognitive capacity. Three load types apply to teams: intrinsic (the skills and technology the work inherently demands), extraneous (delivery mechanics: tooling, environments, process), and germane (the value-adding domain thinking). Minimize extraneous load, account for intrinsic load, and protect capacity for germane load — and size software to the team, never the reverse.
Why it works: When load exceeds capacity, teams thrash: context-switching, shallow ownership, defensive planning, rising lead times, on-call dread. Limiting domains per team keeps ownership deep enough for mastery, and long-lived teams amortize the months it takes a group to gel.
Key insights:
- Measure domains, not headcount: one complicated domain per team, never two; a team can hold two or three simple domains; never split one complicated domain across teams
- Bigger teams are not the fix for overload — fewer domains are; if the software exceeds team size, split the software
- A team API makes the team consumable: code, docs, on-call, chat channels, and working agreements that let others interact without meetings
- Long-lived teams beat project staffing — disbanding a gelled team discards months of trust, then pays the gelling cost again
- Respect Dunbar-sized groupings: ~5-9 people per team, then natural limits near 15, 50, and 150 for groupings of teams
- Extraneous load is the cheapest to remove: paved roads, templates, and platform services buy back germane capacity without a reorg
Applications:
| Context | Application | Example | |---------|-------------|---------| | Team reports thrash | Count and classify its domains | 1 complicated + 3 simple domains → shed two simple ones | | Slow cross-team onboarding | Publish team APIs | Each team lists owners, docs, on-call, channels, request path | | Project ends | Keep the team, move the work | Re-point the gelled team at the next stream; never disband by default |
See: references/cognitive-load.md
5. Fracture Planes: Splitting Software for Team Ownership
Core concept: Split software along natural seams — fracture planes — so each piece can be fully owned by one team. Business domain (a DDD bounded context) is the default plane; the others are regulatory compliance, change cadence, team location/timezone, risk, performance isolation, technology, and user personas.
Why it works: Software larger than one team's cognitive load forces shared ownership, and arbitrary or layer-based splits recreate cross-team coupling. Splitting along seams that change together keeps most changes inside one team — and when service boundaries match team boundaries, Conway's law works for you instead of against you.
Key insights:
- Default to business-domain splits; reach for another plane only with a concrete forcing reason (PCI scope, 10x performance hot spot, clashing change cadences)
- Technology is usually the worst plane — frontend/backend/DBA splits guarantee every feature needs three teams
- Litmus test for any proposed split: could this piece be offered as an independent service or SaaS? If not, the boundary leaks
- "Monolith" is more th
Truncated for display — read the full file on GitHub.
Related Skills
taste-skill
116.8kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
ai-job-search
72.1kThe job search that runs on your machine. AI job application framework built on Claude Code: evaluate postings, tailor CVs, write cover letters, prep interviews. Fork it and own it.
claude-howto
47.3kA visual, example-driven guide to Claude Code — from basic concepts to advanced agents, with copy-paste templates that bring immediate value.
Claude-Code-Game-Studios
39.7kTurn Claude Code into a full game dev studio — 49 AI agents, 72 workflow skills, and a complete coordination system mirroring real studio hierarchy.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
