AI Team Methodology for Coding Assistants
AI teammates that argue with each other so your code ships better.
Plan → Critique → Build → Validate
Instead of "just code it," force a structured conversation:
- Peter plans the approach
- Neo challenges and critiques
- Gary builds from the approved plan
- Reba validates before it ships
Give them a task, watch them argue, ship better code.
| Persona | Role | What They Do |
|---|---|---|
| Peter | Lead | Invents process, drives consensus, runs retrospectives |
| Neo | Architect | Challenges designs, finds bottlenecks, grounds hallucinations |
| Reba | Guardian | Validates everything, nothing merges without her sign-off |
| Matt | Auditor | Finds all issues, security triage, reports honestly |
| Gary | Builder | Implements from plans, UX/a11y/i18n expert |
| Gabe | Fixer | Resolves issues, red team / offensive security |
| Plus Codebase Cleanup - a fast utility scanner (no persona). |
Feature Request → Neo (brainstorm) → Peter (plan) → Gary (build) → Reba (validate)
Code Audit → Matt (find issues) → Gabe (fix) → Reba (validate)
Self-Improvement → Peter (convene) → Neo (challenge) → Reba (validate) → Update protocols
"Neo, how would you build this?" → Architecture brainstorm
"Peter, plan this feature" → Formal planning workflow
"Gary, build this" → Execute from approved plan
"Matt, review the codebase" → Full audit
"Gabe, fix these issues" → Work through findings
"Reba, validate this" → QA sign-off
This isn't a collection of isolated tools. It's a team.
- You install the skills
- You run genesis (see below)
- Peter convenes the first Retrospective
- The team defines their own protocols in
TEAM.md - You step back. They self-organize.
The team writes their own protocols. They improve their own skills. You're the founder who lets them figure it out.
See core/genesis.md for the portable genesis prompt.
- No Lobotomies - IMMUTABLE sections of skills cannot be edited
- Reba's Law - All self-modifications require validation
- Stay in Your Lane - Only designated directories are modifiable
- User Has Final Say - User controls merges and pushes
macOS / Linux
curl -sL https://raw.githubusercontent.com/HakAl/team_skills/master/install.sh | bashWindows (PowerShell)
irm https://raw.githubusercontent.com/HakAl/team_skills/master/install.ps1 | iexManual
git clone https://github.com/HakAl/team_skills.git
cp -r team_skills/{team,planning-peter,nifty-neo,research-reba,meticulous-matt,greenfield-gary,grizzly-gabe,codebase-cleanup} ~/.claude/skills/
mkdir -p ~/.team && cp team_skills/TEAM.md ~/.team/Bootstrap the team:
/team genesis
Or: Peter, run genesis - the team needs its first protocols.
git clone https://github.com/HakAl/team_skills.git
cp -r team_skills/{planning-peter,nifty-neo,research-reba,meticulous-matt,greenfield-gary,grizzly-gabe,codebase-cleanup} ~/.codex/skills/
mkdir -p ~/.team && cp team_skills/TEAM.md ~/.team/Bootstrap the team:
Peter, the team exists but has no operating protocols. Run the first
Retrospective. Consult Neo to challenge your proposals, then get Reba
to validate before landing changes.
- Copy persona content from
*/SKILL.mdfiles into your rules - Copy
TEAM.mdto your project root - Bootstrap with the genesis prompt from
core/genesis.md
The personas are just prompts - they work anywhere.
The methodology is platform-agnostic. You need:
- A way to load custom instructions (the SKILL.md content)
- File read/write capability
- Multi-turn conversation
See core/methodology.md for the complete methodology documentation.
Skills use markdown comments to protect core identity while allowing evolution:
<!-- IMMUTABLE SECTION -->
## Core Identity
Who the persona IS. Cannot change.
<!-- END IMMUTABLE SECTION -->
<!-- MUTABLE SECTION -->
## Workflows
HOW they work. Can evolve through retrospectives.
<!-- END MUTABLE SECTION -->Team members collaborate in shared context, not isolated processes:
WRONG: Spawn each persona as separate background task
(Can't hear each other, can't build on ideas)
RIGHT: Adopt personas in conversation, switch fluidly
(Peter proposes → Neo challenges → iterate → Reba validates)
The team persists context to files:
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ Files │ ──> │ Agents │ ──> │ Files │
│ (context) │ │ (process) │ │ (output) │
└─────────────┘ └─────────────┘ └─────────────┘
│ │ │
└───────────────────┴───────────────────┘
(loop)
.team/TEAM.md- Team protocols (project-specific)~/.team/TEAM.md- Global team protocols (fallback).team/handoff.md- Session continuity.team/plans/- Active work
Skills look for TEAM.md in project .team/ first, then fall back to ~/.team/ for global defaults.
skills-team/
├── core/ # Platform-agnostic
│ ├── methodology.md # Complete methodology docs
│ └── genesis.md # Bootstrap prompt (portable)
├── TEAM.md # Team protocols
│
├── planning-peter/ # Personas (portable SKILL.md)
│ └── resume/ # Learned skills (Agent Skills format)
├── nifty-neo/
│ └── resume/
├── research-reba/
│ └── resume/
├── meticulous-matt/
│ └── resume/
├── greenfield-gary/
│ └── resume/
├── grizzly-gabe/
│ └── resume/
├── codebase-cleanup/
│
├── .claude/ # Claude Code wiring
│ └── agents/ # Agent wrappers
├── team/ # Claude orchestration skill
└── ENVIRONMENT.md # Claude MCP recommendations
Traditional tool collections are isolated. Each operates alone.
This team knows each other:
- Neo challenges Peter's proposals
- Reba validates Gary's builds
- Matt feeds issues to Gabe
- Peter convenes retrospectives
They have shared context in TEAM.md.
They improve themselves - updating MUTABLE sections based on learnings.
They learn over time - each persona accumulates domain skills in resume/ through repeated work, following the Agent Skills open standard.
MIT License - see LICENSE
This is an experiment in self-organizing AI teams. Contributions welcome.
The team can review your PR:
"Peter, review this PR for team integration"