You've seen what's possible — agents that refactor incrementally, write tests first, review their own code, optimize the codebase for AI. But getting there means weeks of trial and error. Symposia is the shortcut.
+ sym-refactoring@1.0.0 — synced to 3 agents
→ Verifying test coverage... 87%
→ Step 1/4: Extract validateToken()... tests green
→ Step 2/4: Move to auth/tokens.ts... tests green
→ Step 3/4: Rename legacy fields... tests green
→ Step 4/4: Remove dead code... tests green
4 commits, 0 regressions
Your agent generates code, but it doesn't engineer. No test-first discipline. No incremental refactoring. No self-review. The gap between Level 2 and Level 5 is the difference between a fast typist and a senior engineer.
Each Symposia package moves you up a level. The question is: where are you now?
See the path to Level 5Answers questions, writes snippets. Forgets everything between sessions.
Writes features end-to-end. No tests-first, no incremental refactoring, no review. Fast but fragile.
TDD with Red→Green→Refactor. Safe refactoring with test gates. Code review with severity triage. Process, not just output.
sym-tdd · sym-refactoring · superpowers-code-review
Decomposes projects into phased plans. Dispatches parallel agents in isolated worktrees. Approval gates before execution.
sym-project-manager · superpowers-git-worktrees
Scores the codebase across 6 AI-readiness dimensions, generates fix plans, applies improvements. The agent optimizes its own environment.
adx
Getting from Level 2 to Level 5 isn't about better prompts. It's about teaching your agent multi-step engineering processes — and right now, there's no good way to do that.
Demos of agents building full features autonomously. You try it and get spaghetti. The difference isn't the model — it's the workflow driving it.
They've built multi-step processes — test-first, incremental refactoring, review gates. But that knowledge lives in their CLAUDE.md files, their custom setups, their heads.
Nobody teaches 'advanced AI-assisted engineering.' You're left reverse-engineering workflows from scattered blog posts and dotfiles. Trial and error, for weeks.
Symposia packages are installable engineering workflows. Add one to your project, and your AI agent immediately follows the process — no configuration, no training.
sym add sym-tdd writes structured workflow instructions into your project.
Your AI agent automatically discovers and follows the workflow — TDD, refactoring, review, whatever you installed.
Add more packages. Your agent writes tests first, refactors safely, then reviews its own output — autonomously.
Each package unlocks a new capability. Start anywhere — they're standalone — but together they compound into an agent that engineers autonomously.
Red → Green → Refactor cycle, enforced automatically. Your agent writes the failing test, implements the minimum to pass, then cleans up. Decision logic for when TDD applies and when to skip it.
Atomic change → test → commit loop. Red triggers automatic revert. Behavior changes are forbidden during refactoring — the agent enforces the boundary. Every commit is a safe rollback point.
Your agent dispatches a reviewer subagent that evaluates plan alignment, code quality, and architecture — then categorizes issues as Critical, Important, or Minor with file:line references.
Breaks projects into phased plans with explicit file ownership per task. Dispatches parallel agents in isolated worktrees. Progress tracked in PLAN.md — user approves before execution begins.
6-dimension scoring — types, testing, guardrails, structure, context, readability — surfaces what's degrading agent output. Generates a prioritized fix plan and applies improvements automatically.
+ 3 packages synced to Claude Code, Cursor
tdd
→ Writing failing test for rate limit middleware... red
→ Implementing minimum to pass... green
refactoring
→ Extract RateLimiter class... green
→ Move to middleware/rate-limit.ts... green
code review
→ Dispatching reviewer...
→ 0 critical · 1 minor (naming) approved
3 workflows · 4 commits · 0 regressions
One natural language prompt. Three workflows fire automatically.
These aren't guidelines your agent might follow. They're executable processes with verification gates, rollback points, and structured output.
Your agent checks test coverage, then executes one atomic change at a time — extract, move, rename, delete — running the full test suite between each step. Red means instant revert, not a broken branch. Every commit is a safe rollback point.
→ Verifying test coverage... 87%
→ Extract validateToken() green
→ Move to auth/tokens.ts green
→ Rename legacy fields green
→ Remove dead code green
4 commits, 0 regressions
ADX runs a 6-dimension audit — types, testing, guardrails, structure, context, readability — and surfaces exactly what's degrading agent output. Then it generates a prioritized fix plan and applies improvements automatically, in severity order.
23 escape hatches · 0 ADRs · no CLAUDE.md
run /adx-dashboard plan for fixes
The gap between your strongest AI user and everyone else keeps widening. Symposia makes advanced workflows installable — so the whole team climbs, not just one person.
New hire runs sym add and gets every workflow the team uses — TDD, refactoring, code review — configured for every AI agent they have. Day-one productivity, not week-three.
Codify proprietary workflows — your deployment process, your review standards, your architecture patterns — as private packages only your org can install.
Distill hard-won engineering knowledge into packages with sym create-package. Your team's best practices become installable, versioned artifacts — not tribal knowledge.
Pin workflow versions across repos. Roll out updates deliberately. Review changes to agent instructions in PRs — the same way you review code.
One install syncs workflows to Claude Code, Cursor, Copilot, Aider, and every other agent on your team. No drift between tools, no per-agent configuration.
Built a workflow that works? Publish it to the Symposia registry with sym publish. Share what you've learned with every team using AI agents.
Three commands. Your agent goes from generating code to engineering it — with tests, safe refactoring, and self-review built in.
$ npm install -g symposia
$ sym init
$ sym add sym-tdd sym-refactoring superpowers-code-review
Stay in the loop
Get notified about new packages and features. No spam, unsubscribe anytime.