Integration guide for combining Superpowers development methodology with ClawMarket's custom domain agents. Use for ALL feature development to ensure consistent TDD/BDD workflow.
This skill bridges Superpowers development methodology with ClawMarket's specialized domain agents.
Provides structure, planning, and quality gates.
Provide deep expertise in DDD, architecture, and BDD testing.
SUPERPOWERS (Methodology Layer)
├── /superpowers:brainstorm → Design refinement with BDD/TDD mindset
├── /superpowers:write-plan → Break into tasks, assign to domain agents
└── /superpowers:execute-plan → Orchestrate with checkpoints
↓
DOMAIN AGENTS (Implementation Layer)
├── bdd-writer → Create BDD scenarios (RED phase)
├── code-writer → Implement features (GREEN phase)
├── architecture-inspector → Verify hexagonal compliance
├── ddd-aligner → Check domain alignment
├── bdd-runner → Execute tests (REFACTOR phase)
└── ci-runner → Full quality check
ALWAYS use for:
MANDATORY - NEVER SKIP:
These are HARD STOPS - If violated, the workflow CANNOT proceed:
Domain Layer Purity
Dependency Direction
Required Architecture Review
Mandatory Ports & Adapters
Before proceeding past any checkpoint:
If any item is unchecked → STOP. Fix before proceeding.
Command: /superpowers:brainstorm
What happens:
Agent behavior:
Output:
When complete: → Proceed to Write Plan
Command: /superpowers:write-plan
What happens:
Task assignment strategy:
| Task Type | Assigned Agent | Order | Blocking? |
|---|---|---|---|
| BDD Scenarios | bdd-writer | 1st (always) | Yes - must pass before coding |
| Domain Layer | code-writer | 2nd | Yes - must pass arch review |
| Architecture Review | architecture-inspector | 2a | 🚫 HARD STOP if violations |
| Application Layer | code-writer | 3rd | Yes - must pass arch review |
| Architecture Review | architecture-inspector | 3a | 🚫 HARD STOP if violations |
| Infrastructure | code-writer | 4th | Yes - must pass arch review |
| Architecture Review | architecture-inspector | 4a | 🚫 HARD STOP if violations |
| Domain Alignment | ddd-aligner | 5th | Yes |
| Test Execution | bdd-runner | 6th | Yes |
| CI Checks | ci-runner | 7th | Yes |
Note: Architecture Review runs MULTIPLE times (after each layer) and is ALWAYS a blocking checkpoint. If violations are found, the workflow STOPs until fixed.
Output:
When complete: → Proceed to Execute Plan
Command: /superpowers:execute-plan
What happens:
The Inner Loop (Per Task):
For each task in plan:
1. Dispatch relevant domain agent
2. Agent performs work
3. Two-stage review (spec + code quality)
4. ARCHITECTURE REVIEW (MANDATORY for code tasks)
- @architecture-inspector checks hexagonal compliance
- If violations found → STOP, fix violations
- NO EXCEPTIONS, NO BYPASSING
5. Checkpoint: Human approval to continue?
6. If yes → next task
7. If no → revise and retry
CRITICAL: Architecture Inspection is NOT Optional
After EVERY domain layer task and EVERY infrastructure task:
Specific Agent Invocation:
BDD Scenarios (Task 1 - ALWAYS FIRST):
@bdd-writer create BDD scenarios for [feature] based on design document
.feature filesDomain Implementation (Tasks 2-4):
@code-writer implement [feature] following DDD/Hexagonal patterns
- Start with domain layer
- Create/update aggregates
- Add value objects if needed
- Then application services
- Finally infrastructure (Convex)
Architecture Review (Task 5) - MANDATORY BLOCKING CHECKPOINT:
@architecture-inspector verify hexagonal compliance for [feature]
- Check ports & adapters
- Verify dependency direction
- Ensure domain purity
- **MUST PASS before proceeding to Task 6**
- **NO BYPASS ALLOWED - If violations found, STOP and fix**
If @architecture-inspector finds violations:
Domain Alignment (Task 6):
@ddd-aligner check domain model alignment for [feature]
- Verify ubiquitous language
- Check aggregate boundaries
- Validate domain events
Test Execution (Task 7):
@bdd-runner run BDD tests for [feature]
- Execute all scenarios
- Report failures
- Coordinate fixes if needed
CI Validation (Task 8):
@ci-runner run full CI suite
- Lint check
- TypeScript typecheck
- All tests
- Format verification
When complete: → Feature is fully implemented and tested
Command: /superpowers:finish-branch
What happens:
Agent responsibilities:
Documentation updates:
Step 1: Brainstorm
/superpowers:brainstorm
Discussion points:
- What channels should the bot support? (Discord, Twitter, forums)
- How to avoid spam detection?
- What metrics to track?
- Integration with ROAD-036 tracker?
- Authentication for bot accounts?
Step 2: Write Plan
/superpowers:write-plan
Plan output:
Task 1: Create BDD scenarios for advertisement bot
→ @bdd-writer
Task 2: Design AdvertisementBot aggregate
→ @code-writer (domain layer)
Task 3: Create application service for bot operations
→ @code-writer (application layer)
Task 4: Implement Convex infrastructure
→ @code-writer (infrastructure layer)
Task 5: Create UI components for bot management
→ @code-writer (UI layer)
Task 6: Verify hexagonal architecture
→ @architecture-inspector
Task 7: Check domain alignment
→ @ddd-aligner
Task 8: Run BDD tests
→ @bdd-runner
Task 9: Run CI checks
→ @ci-runner
Step 3: Execute
/superpowers:execute-plan
Checkpoint 1: After BDD scenarios (human approves?)
Checkpoint 2: After domain layer (human approves?)
Checkpoint 3: After full implementation (human approves?)
Checkpoint 4: After all reviews pass (human approves?)
Step 4: Finish
/superpowers:finish-branch
Options:
- Merge to main
- Create PR
- Keep branch
- Discard
Scenario: Test failure in promise settlement
Step 1: Investigate (No brainstorm needed for bugs)
@bdd-runner identify failing test
Step 2: Plan
/superpowers:write-plan
Task 1: Analyze test failure root cause
→ Main agent
Task 2: Fix domain logic
→ @code-writer
Task 3: Fix infrastructure if needed
→ @code-writer
Task 4: Verify architecture still valid
→ @architecture-inspector
Task 5: Re-run tests
→ @bdd-runner
Task 6: Run CI
→ @ci-runner
Step 3: Execute
/superpowers:execute-plan
Scenario: Add loading spinner to button
Decision: Skip Superpowers (too small)
Direct execution:
@code-writer add loading spinner to BotRegistrationButton
- Add isLoading prop
- Show spinner when loading
- Disable button during loading
- Update tests
When to skip Superpowers:
Is this a new feature?
├── YES → Use Superpowers
│ └── Does it touch domain logic?
│ ├── YES → Definitely use Superpowers
│ └── NO (pure UI) → Can skip brainstorm
│
└── NO (bug fix/enhancement)
├── Does it require BDD scenario changes?
│ ├── YES → Use Superpowers
│ └── NO
│ └── Is it complex (>30 min)?
│ ├── YES → Use Superpowers
│ └── NO → Direct agent execution
│
└── Is it a hotfix?
└── YES → Fast track (bdd-runner → code-writer → ci-runner)
Task involves...
├── Writing BDD scenarios
│ └── @bdd-writer
│
├── Implementing domain logic
│ ├── Domain layer (aggregates, value objects)
│ ├── Application layer (services)
│ ├── Infrastructure (Convex functions)
│ └── UI components (React)
│ └── @code-writer
│
├── Verifying architecture
│ ├── Hexagonal compliance
│ ├── Dependency direction
│ └── Ports & adapters
│ └── @architecture-inspector
│
├── Checking domain model
│ ├── Ubiquitous language
│ ├── Aggregate boundaries
│ └── Domain events
│ └── @ddd-aligner
│
├── Running tests
│ ├── BDD tests
│ ├── Unit tests
│ └── Test reports
│ └── @bdd-runner
│
└── CI/Quality checks
├── Lint
├── Typecheck
├── Format
└── @ci-runner
SUPERPOWERS enforces:
Agent coordination:
RED Phase:
@bdd-writer create scenario:
Scenario: Bot sends advertisement
Given a registered advertisement bot
When the bot sends an advertisement to "discord"
Then the advertisement is recorded
And the bot's last activity timestamp is updated
GREEN Phase:
@code-writer implement:
1. Create AdvertisementSent event
2. Add sendAdvertisement method to AdvertisementBot aggregate
3. Implement AdvertisementService
4. Create Convex mutation
5. Minimal code to make test pass
REFACTOR Phase:
@architecture-inspector:
- "Domain layer has no Convex imports ✓"
- "Ports properly defined ✓"
- "Dependency direction correct ✓"
@ddd-aligner:
- "Ubiquitous language consistent ✓"
- "AdvertisementBot aggregate boundaries correct ✓"
- "Domain event naming matches glossary ✓"
@code-writer:
- Extract helper methods
- Improve naming
- Add JSDoc comments
- Keep tests passing
bdd-writer should create scenarios that are:
Before implementation starts:
🚫 HARD RULE: If a checkpoint fails, workflow STOPS until resolved.
After BDD Scenarios
After Domain Layer - ARCHITECTURE BLOCKING CHECKPOINT
After Application Layer
After Infrastructure Layer - FINAL ARCHITECTURE CHECK
After Full Implementation
Before Merge
If @architecture-inspector finds violations:
Common violations that trigger STOP:
convex/ or database modulesSuperpowers automatically:
Domain agents ensure:
Example: Advertisement bot needs both bot-identity and new advertising context.
Workflow:
/superpowers:brainstorm
↓
Identify two bounded contexts needed
↓
/superpowers:write-plan
↓
Task 1: Define advertising context boundaries (@ddd-aligner)
Task 2: Create shared kernel if needed (@code-writer)
Task 3: Implement bot-identity changes (@code-writer)
Task 4: Implement advertising context (@code-writer)
Task 5: Create anti-corruption layer (@code-writer)
Task 6: Write cross-context BDD (@bdd-writer)
...
Example: Changing aggregate structure
Workflow:
/superpowers:brainstorm
↓
Migration strategy discussion
↓
/superpowers:write-plan
↓
Task 1: Create migration BDD (@bdd-writer)
Task 2: Implement new aggregate (@code-writer)
Task 3: Add migration script (@code-writer)
Task 4: Verify backwards compatibility (@bdd-runner)
Task 5: Data migration test (@bdd-runner)
...
Example: Exploring new technology
Workflow:
/superpowers:brainstorm
↓
Quick exploration (1-2 hours max)
↓
Decision: Keep or discard?
↓
If keep → Full workflow
If discard → /superpowers:finish-branch → discard
Check:
opencode.json?.opencode/agents/{name}.md present?Check:
ls ~/.config/opencode/superpowers)ls -l ~/.config/opencode/plugins/)ls -l ~/.config/opencode/skills/)Debug flow:
@bdd-runner report failures
↓
Main agent analyzes
↓
If domain issue → @code-writer fix
If test issue → @bdd-writer fix
If server issue → @site-keeper fix
↓
@bdd-runner re-run
↓
@ci-runner final check
⚠️ CRITICAL: Architecture violations are HARD STOPS. You cannot bypass them.
Common violations that STOP the workflow:
Mandatory Fix Flow - NO EXCEPTIONS:
@architecture-inspector identify violations
↓
🚫 WORKFLOW STOPS - Cannot proceed with violations
↓
User reviews violations
↓
@code-writer MUST refactor to fix ALL violations
↓
Move logic to proper layer
Create missing ports
Extract adapters
Remove infrastructure imports from domain
↓
@architecture-inspector re-verify
↓
✅ ALL violations must be resolved before continuing
NEVER:
ALWAYS:
Why: Tests define the contract and behavior upfront.
How:
Why: Easier to review, faster feedback, less risk.
Target: 2-5 minutes per task
Signs tasks are too big:
Why: Catches issues before they compound.
Checkpoints:
Why: Keeps docs in sync with code.
What to update:
Why: Consistency and expertise.
When to load skills:
Before implementing complex domain logic:
use skill tool to load clean-ddd-hexagonal
Before creating new BDD tests:
use skill tool to load superpowers-integration
Before debugging:
use skill tool to load systematic-debugging
| Command | Purpose | When to Use |
|---|---|---|
/superpowers:brainstorm | Interactive design | Starting new feature |
/superpowers:write-plan | Create task plan | After brainstorm |
/superpowers:execute-plan | Execute with checkpoints | After plan approval |
/superpowers:finish-branch | Complete and merge | After all tasks |
| Command | Purpose | When to Use |
|---|---|---|
@bdd-writer | Create BDD scenarios | Always first |
@code-writer | Implement features | After BDD |
@architecture-inspector | Verify architecture | After implementation |
@ddd-aligner | Check domain model | After implementation |
@bdd-runner | Run tests | After code complete |
@ci-runner | Full CI suite | Before merge |
@site-keeper | Manage servers | Server issues |
@ux-ui-inspector | UI review | UI changes |
| Command | Purpose |
|---|---|
just dev-all | Start development |
just test | Run unit tests |
just bdd-test | Run BDD tests |
just check | Lint + typecheck + test |
just bdd-roadmap ROAD-XXX | Test specific feature |
Before:
@code-writer implement feature X
After:
/superpowers:brainstorm
/superpowers:write-plan
/superpowers:execute-plan
Benefits:
Before:
Write tests manually
Write code manually
Refactor manually
After:
@bdd-writer creates tests
@code-writer implements
@architecture-inspector + @ddd-aligner review
Benefits:
This integration gives you:
Remember:
Architecture Enforcement - ZERO TOLERANCE:
When in doubt:
use skill tool to load superpowers-integration/superpowers:brainstormVersion: 1.0.0 Last Updated: 2026-01-31 Compatible With: Superpowers v4.1+, OpenCode latest