This skill defines the end-to-end workflow for implementing complete features that span multiple layers of the stack. It orchestrates specialized agents through 7 distinct phases, from requirements clarification through delivery.
When to Use This Skill
Use fullstack-feature when the user requests:
A complete feature that requires database, API, and UI changes
End-to-end implementation with testing and review
A new user-facing capability that touches multiple components
Anything described as: "build X", "add X feature", "implement X capability"
Do NOT use this skill for:
Single-layer changes (just API, just UI)
Bug fixes (use bugfix or hotfix skills)
Code review only (use review-scoring skill)
Refactoring without new functionality
Overview
The fullstack feature workflow consists of 7 phases:
Protocol skills (required for all agents): gather-plan-apply, precision-mastery, error-recovery, goodvibes-memory
Run type generation command
Verify types are correct (spot check generated code)
Run
tsc
to confirm no type errors
Clear Definition of Done
Database schema exists, migrations applied
Types generated and exported
npm run typecheck
passes
All files committed
Mode-Specific Behavior
Vibecoding
Checkpoint after this phase. Commit with message
checkpoint: foundation - schema and types
.
Justvibes
Auto-proceed to Phase 3.
Phase 3: Core Implementation (Parallel)
Purpose
Implement the main functionality across API and UI layers in parallel. This maximizes throughput and minimizes wait time.
Sub-Phases
These sub-phases run in parallel:
API endpoints
(API agent)
UI components
(UI agent)
State management
(State agent)
Agent Instructions
API agent
:
Protocol skills (required for all agents): gather-plan-apply, precision-mastery, error-recovery, goodvibes-memory
Implement endpoints using existing patterns (check decisions.json for API style)
Add input validation (use Zod or similar)
Add error handling
Add authentication/authorization checks
Use ORM for database access
Add logging at appropriate levels
Use
gather-plan-apply
protocol
UI agent
:
Protocol skills (required for all agents): gather-plan-apply, precision-mastery, error-recovery, goodvibes-memory
Create components using existing patterns (check decisions.json for UI libraries)
Follow accessibility best practices (ARIA attributes, keyboard navigation)
Implement responsive design
Add loading and error states
Optimize performance (
useMemo
,
useCallback
)
Use
gather-plan-apply
protocol
State agent
:
Protocol skills (required for all agents): gather-plan-apply, precision-mastery, error-recovery, goodvibes-memory
Implement state management using existing patterns (Zustand, Redux, etc)
Define state shape and actions
Add selectors for derived state
Add persistence if required (localStorage, sessionStorage)
Use
gather-plan-apply
protocol
Clear Definition of Done
All API endpoints implemented and validated
All UI components created
State management implemented
npm run typecheck
passes
npm run lint
passes
All files committed
Mode-Specific Behavior
Vibecoding
Checkpoint after this phase. Commit with message
checkpoint: core implementation
.
Justvibes
Auto-proceed to Phase 4.
Phase 4: Integration (Sequential)
Purpose
Connect UI to API, wire state to UI, and verify data flows end-to-end. This phase must be sequential because it depends on Phase 3 completion.
Steps
Wire UI to API
:
Add API client calls to components
Handle loading states during API calls
Handle error states from API
Display API responses in UI
Wire state to UI
:
Connect state management to components
Use selectors to access state
Dispatch actions on user interactions
Verify UI updates when state changes
End-to-end verification
:
Manually test data flow: UI -> API -> Database -> API -> UI
Confirm loading states appear
Confirm error states appear on failure
Confirm success states appear on success
Fix integration issues
:
Fix type mismatches between UI and API
Fix data mapping issues
Fix state synchronization issues
Agent Instructions
Integration agent
:
Protocol skills (required for all agents): gather-plan-apply, precision-mastery, error-recovery, goodvibes-memory
Read both API and UI code to understand interfaces
Add API client calls in correct lifecycle hooks (
useEffect
, event handlers)
Ensure error handling is present
Ensure loading states are displayed
Test each integration point manually
Use
gather-plan-apply
protocol
Clear Definition of Done
UI components can call API endpoints
Data flows from UI -> API -> DB -> API -> UI
State works correctly
Loading states display
Error states display
npm run typecheck
passes
All files committed
Mode-Specific Behavior
Vibecoding
Checkpoint after this phase. Commit with message
checkpoint: integration
.
Justvibes
Auto-proceed to Phase 5.
Phase 5: Quality (Parallel)
Purpose
Verify the implementation meets quality standards across multiple dimensions. These checks run in parallel. Each spawned agent will have its own WRFC chain managed by the runtime engine.
Sub-Phases
These sub-phases run in parallel:
Tests
(Tester agent)
Security check
(Security agent)
Accessibility check
(A11y agent)
Agent Instructions
Tester agent
:
Protocol skills (required for all agents): gather-plan-apply, precision-mastery, error-recovery, goodvibes-memory
Write unit tests for API endpoints
Write component tests for UI
Write integration tests for data flow
Target >=80% coverage for new code
Test both happy path and edge cases
Use
gather-plan-apply
protocol
Security agent
:
Protocol skills (required for all agents): gather-plan-apply, precision-mastery, error-recovery, goodvibes-memory
Check for input validation on all endpoints
Check for authentication/authorization checks
Check for SQL injection vulnerabilities
Check for XSS vulnerabilities
Check for exposed secrets
Check for CORS configuration
Use
gather-plan-apply
protocol
A11y agent
:
Protocol skills (required for all agents): gather-plan-apply, precision-mastery, error-recovery, goodvibes-memory
Check for ARIA attributes on interactive elements
Check for keyboard navigation support
Check for color contrast (WCAG AA)
Check for focus indicators
Check for alt text on images
Use
gather-plan-apply
protocol
Clear Definition of Done
Tests written and passing
Security check complete (no critical issues)
Accessibility check complete (no critical issues)
All files committed
Mode-Specific Behavior
Vibecoding
Checkpoint after this phase. Commit with message
checkpoint: quality checks
.
Justvibes
Auto-proceed; runtime handles review cycles.
Phase 6: Review (Runtime-Driven)
Purpose
Ensure all code meets production standards through systematic review and fix. The runtime engine manages this phase automatically via
directives.
How It Works
The orchestrator does NOT manually spawn reviewers. Instead:
Each work agent from Phases 2-5 completes and emits a
tag
The runtime engine evaluates the output and issues directives:
The orchestrator executes each directive immediately and mechanically
Orchestrator Behavior
On
spawn
directive: spawn the specified agent with the provided task prompt
On
complete
directive: mark the chain done, proceed to Phase 7 when all chains complete
On
escalate
directive: report to user with the escalation reason; do not attempt to fix the chain manually
Clear Definition of Done
All WRFC chains have received
complete
directives from the runtime
No chains are pending escalation resolution
Mode-Specific Behavior
Both vibecoding and justvibes modes follow directives identically. The runtime engine determines when review cycles end. The orchestrator has no mode-specific behavior in this phase beyond executing directives.
Phase 7: Commit + Log
Purpose
Finalize the feature by committing to git and updating project memory. This phase is triggered when the runtime issues
Confirm commit message with user before committing.
Justvibes
Auto-commit with generated message.
Mode-Specific Behavior
Vibecoding Mode
Vibecoding mode is collaborative. The orchestrator:
Confirms
after Phase 1 (Understand) before proceeding
Checkpoints
after Phases 2, 3, 4, 5 (creates git commits)
Confirms
commit message before final commit in Phase 7
Pauses for approval if uncertainties arise
Once agents are spawned, the runtime engine drives WRFC chains automatically. The orchestrator executes directives mechanically regardless of mode.
Checkpoint commit messages:
checkpoint: foundation - schema and types
checkpoint: core implementation
checkpoint: integration
checkpoint: quality checks
Justvibes Mode
Justvibes mode is autonomous. The orchestrator:
Auto-proceeds
through all phases without user input
Pauses only if requirements are ambiguous or critical decisions are needed
Auto-commits in Phase 7 (generates commit message)
The runtime engine manages all WRFC cycles in both modes identically.
Agent Orchestration Patterns
Sequential Phases
Phases 2, 4, 7 must be sequential:
Phase 2 (Foundation)
Must complete before Phase 3 because API/UI code depends on types
Phase 4 (Integration)
Must come after Phase 3 because it connects API+UI
Phase 7 (Commit+Log)
Must be last; triggered by
complete
directives for all chains
Parallel Phases
Phases 3 and 5 spawn multiple agents in parallel:
Phase 3 (Core)
API agent, UI agent, State agent run in parallel
Phase 5 (Quality)
Tester agent, Security agent, A11y agent run in parallel
All agents in a parallel phase must receive
complete
directives before proceeding to the next phase.
Agent Communication
Agents should NOT communicate directly. Instead:
Agents write results to filesystem
Orchestrator reads agent outputs
Orchestrator passes relevant info to next agents
Integration with Other Protocols
Gather-Plan-Apply (GPA)
All work agents must follow the GPA loop:
Discover
Use
discover
tool to run parallel grep/glob/symbol queries
Plan
Identify files to create/modify, order of operations, batch opportunities
Batch
Group operations into batched precision_engine calls
Loop
Return to discovery if assumptions change
See
gather-plan-apply
skill for details.
Review-Scoring (WRFC)
The runtime engine uses the review-scoring rubric internally when spawning reviewers. The orchestrator does not score code directly. Review thresholds are configured in
goodvibes.json
(
min_review_score
,
max_fix_attempts
).
See
review-scoring
skill for details on what the reviewer agent does.
Goodvibes Memory
Use
goodvibes-memory
skill to:
Read
.goodvibes/memory/{decisions,patterns,failures}.json
in Phase 1
Write to
.goodvibes/logs/tasks.jsonl
in Phase 7
Update memory files with new patterns/decisions in Phase 7
Common Pitfalls
Starting Implementation Too Early
Do not spawn work agents until Phase 1 is complete. Clarify requirements first.
Parallelizing Sequential Phases
Do not run Phases 2 and 3 in parallel. Phase 3 depends on Phase 2 types.
Skipping Quality Phase
Do not skip Phase 5. Tests are not optional. Security is not optional.
Manually Scheduling Reviewers
Do not add reviewer tasks to Phase 6 manually. The runtime engine issues reviewer spawn directives automatically when each work agent completes. Manual scheduling bypasses the runtime's threshold enforcement.
Deferring Directives
Do not defer, reorder, or skip
directives. Execute them immediately as the first action when received.
Committing Without All Chains Complete
Do not commit in Phase 7 until all WRFC chains have received
complete
directives. Partial completions are not done.
Forgetting to Update Memory
Do not skip memory updates in Phase 7. Future agents rely on this context.
Validation
Use
scripts/validate-feature-workflow.sh
to verify your orchestration follows this workflow. See
references/phase-templates.md
for detailed templates and examples.