Index-first coordination
Tasks, files, feature wiring, and dev history live in one place so each agent starts informed instead of guessing.
- Shared `.10x` project state
- Task handoffs without context loss
- Safer refactors across agents
Agent-native development system
The AI development team that ships your app end to end.
10x Development Team turns Claude, Codex, Cursor, Windsurf, and more into a coordinated product team. Planning, design systems, backend logic, testing, deployment, and project memory all move through one shared operating model.
$ /start > scope detected: production > team lead assigned > ui-designer -> design system > backend-dev -> contracts + data model > qa-tester -> test pyramid + release gates > deployer -> smoke tests + rollback plan status: building with shared project memory
Works with the AI clients teams already use
Platform
Project memory
Design system
Engineering
Runtime parity
One operating model for planning, building, testing, and shipping.
The plugin packages specialist agents, project memory, reusable knowledge, and deployment discipline into one frontend-ready system. You keep your preferred AI client. The workflow becomes consistent.
Frontend rules with taste
Design-first principles, component reuse, loading states, accessibility, and responsive behavior are built into the instructions.
- Semantic tokens over hardcoded color
- Mobile-first layouts and UI states
- Practical component registry patterns
Production-grade quality gates
Architecture reviews, testing strategy, deployment checklists, rollback plans, and incident response now ship with the plugin.
- Spec before build for serious work
- Test pyramid guidance by scope
- Pre-deploy and post-deploy verification
Claude and Codex stay aligned
Mirrored instruction surfaces and skill libraries mean both runtimes load the same workflows instead of drifting apart.
- Claude knowledge and skill mirrors
- Codex AGENTS and `.agents` support
- One repo, one operational standard
Agents
Leadership
Frontend
Backend
Shipping
0
specialist agents
0
core commands
0
new engineering playbooks
0
AI clients supported
0
quality gates before deploy
0
shared source of truth
A specialist team, not a single all-purpose prompt.
Each agent owns a distinct part of delivery, from the first spec to the final deploy. That separation makes the plugin feel more like a real engineering team.
Team lead
Breaks the work down, routes tasks to the right specialist, and keeps the plan grounded in project state.
Frontend dev + UI designer
Builds polished interfaces, reusable components, strong hierarchy, responsive behavior, and a design system that stays coherent.
Backend dev
Owns APIs, auth, data models, validation, service wiring, and the response contracts your frontend can actually trust.
QA + deployer + recovery
Handles tests, deployment gates, rollback discipline, smoke checks, and the ugly failure modes teams usually leave undocumented.
Process
1
2
3
4
5
From first prompt to production handoff in five clean steps.
The gentic reference uses a crisp step rhythm, so this section does the same while staying true to what your plugin actually delivers.
Capture the brief
The team lead reads the request, detects scope, and turns a loose idea into concrete tasks, expected outputs, and ownership.
Lock the system
Design rules, architecture notes, API expectations, and engineering constraints are defined before implementation expands.
Build in parallel
Frontend, backend, and support work can move at once because the file index and feature map act as the handoff layer.
Verify the release
Tests, build checks, deployment checklists, migration safety, smoke tests, and rollout planning happen before the ship button.
Keep the context
Knowledge files, dev logs, and project memory make the next session faster, cheaper, and far less dependent on chat history.
Commands
Build flow
spec -> gates -> ship
Maintenance flow
fix -> review -> release
Natural language on the outside. Reliable operating procedures underneath.
The plugin keeps the interface simple for builders while making the execution model much stricter behind the scenes.
/start /build /add-page landing-page /connect-data supabase /deploy Behind the scenes: - architecture review - task ownership - response contracts - testing strategy - rollback planning
/fix login redirect loop /review /update-deps /status /resumeproject Behind the scenes: - scoped edits - safer handoffs - persistent memory - production checklists - incident-ready documentation
Install
What ships now
Install paths
Install once, then use the same system across both Claude and Codex.
This redesign also reflects the latest repo changes: mirrored runtime support, updated skills, and new production knowledge files.
Production engineering playbooks included
The plugin now carries deployment, testing, and engineering-standard references that agents can pull directly into implementation work.
- Deployment checklist and rollback protocol
- Testing strategy with unit, integration, and e2e templates
- Engineering standards with DoD, ADRs, gates, and env safety
Pick your runtime and start building
Use the repo directly, install from npm, or wire the plugin into your preferred AI coding environment.
- Codex reads `AGENTS.md` and `.agents/skills/`
- Claude reads `.claude/CLAUDE.md` and `.claude/skills/`
- Both share the same engineering standards and workflows
Ready
Turn your AI client into a real shipping team.
Install the plugin, point it at your project, and let the agents work with clearer ownership, better UI standards, safer releases, and less repeated context.