Load PROACTIVELY when task involves building a complete feature across multiple layers. Use when user says "build a feature", "add user profiles", "create a dashboard", or any request spanning database, API, UI, and tests. Orchestrates multi-agent work sequentially: schema and migrations, API endpoints, UI components, tests, and review. The runtime engine handles WRFC chains automatically via <gv> directives. Handles dependency ordering and cross-layer type sharing.
Orchestrates end-to-end feature implementation across database, API, and UI layers with automated quality checks and review cycles.
/plugin marketplace add mgd34msu/goodvibes-plugin/plugin install goodvibes@goodvibes-marketThis skill inherits all available tools. When active, it can use any tool Claude has access to.
references/phase-templates.mdscripts/validate-feature-workflow.shscripts/
validate-feature-workflow.sh
references/
phase-templates.md
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.
Use fullstack-feature when the user requests:
Do NOT use this skill for:
The fullstack feature workflow consists of 7 phases:
<gv> directivescomplete directives; git commit, update memory/logs, report to userThe runtime engine automatically creates a WRFC (Work-Review-Fix-Complete) chain for each work agent. When an agent completes its work and emits a <gv> tag, the runtime:
min_review_score (default: 9.5 from goodvibes.json)Directive types:
{"action":"spawn","wid":"wrfc_xxx","type":"reviewer","task":"Review the code..."}
{"action":"spawn","wid":"wrfc_xxx","type":"engineer","task":"Fix the issues..."}
{"action":"complete","wid":"wrfc_xxx"}
{"action":"escalate","wid":"wrfc_xxx","reason":"Max fix attempts reached"}
Directive compliance rules (absolute):
The orchestrator does NOT manually spawn reviewers or fix agents. These come exclusively from runtime directives.
Ensure you have complete clarity on what to build before spawning work agents. This phase prevents wasted effort from misunderstandings.
Clarify requirements with the user:
Identify affected layers:
Load relevant outcome skills:
trpc, prisma, postgresql, clerk, nextauth, graphql, rest-api-designnextjs, react, tailwindcss, shadcn-ui, framer-motiongather-plan-apply, review-scoring, goodvibes-memoryCheck goodvibes memory:
.goodvibes/memory/decisions.json - Architectural choices.goodvibes/memory/patterns.json - Coding patterns.goodvibes/memory/failures.json - Past failures to avoidCreate implementation plan:
At the end of Phase 1, you must have:
Vibecoding: Confirm with user before proceeding to Phase 2. Justvibes: Auto-proceed if requirements are clear. (Pause for clarification if ambiguous.)
Establish the data model and type foundation before building any upstream code. This ensures type safety and consistency across layers.
Database schema (if required):
Type generation (if using Prisma/Drizzle/etc):
Shared type definitions (if not using ORM):
src/types/[...].ts filesindex.tsDatabase agent:
Protocol skills (required for all agents): gather-plan-apply, precision-mastery, error-recovery, goodvibes-memory
gather-plan-apply protocolcreatedAt, updatedAt)Engineer agent (type generation):
Protocol skills (required for all agents): gather-plan-apply, precision-mastery, error-recovery, goodvibes-memory
tsc to confirm no type errorsnpm run typecheck passesVibecoding: Checkpoint after this phase. Commit with message checkpoint: foundation - schema and types.
Justvibes: Auto-proceed to Phase 3.
Implement the main functionality across API and UI layers in parallel. This maximizes throughput and minimizes wait time.
These sub-phases run in parallel:
API agent:
Protocol skills (required for all agents): gather-plan-apply, precision-mastery, error-recovery, goodvibes-memory
gather-plan-apply protocolUI agent:
Protocol skills (required for all agents): gather-plan-apply, precision-mastery, error-recovery, goodvibes-memory
useMemo, useCallback)gather-plan-apply protocolState agent:
Protocol skills (required for all agents): gather-plan-apply, precision-mastery, error-recovery, goodvibes-memory
gather-plan-apply protocolnpm run typecheck passesnpm run lint passesVibecoding: Checkpoint after this phase. Commit with message checkpoint: core implementation.
Justvibes: Auto-proceed to Phase 4.
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.
Wire UI to API:
Wire state to UI:
End-to-end verification:
Fix integration issues:
Integration agent:
Protocol skills (required for all agents): gather-plan-apply, precision-mastery, error-recovery, goodvibes-memory
useEffect, event handlers)gather-plan-apply protocolnpm run typecheck passesVibecoding: Checkpoint after this phase. Commit with message checkpoint: integration.
Justvibes: Auto-proceed to Phase 5.
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.
These sub-phases run in parallel:
Tester agent:
Protocol skills (required for all agents): gather-plan-apply, precision-mastery, error-recovery, goodvibes-memory
gather-plan-apply protocolSecurity agent:
Protocol skills (required for all agents): gather-plan-apply, precision-mastery, error-recovery, goodvibes-memory
gather-plan-apply protocolA11y agent:
Protocol skills (required for all agents): gather-plan-apply, precision-mastery, error-recovery, goodvibes-memory
gather-plan-apply protocolVibecoding: Checkpoint after this phase. Commit with message checkpoint: quality checks.
Justvibes: Auto-proceed; runtime handles review cycles.
Ensure all code meets production standards through systematic review and fix. The runtime engine manages this phase automatically via <gv> directives.
The orchestrator does NOT manually spawn reviewers. Instead:
<gv> tag{"action":"spawn","type":"reviewer","task":"..."}{"action":"spawn","type":"engineer","task":"Fix: ..."}min_review_score (configured in goodvibes.json): {"action":"complete"}max_fix_attempts is exhausted: {"action":"escalate","reason":"..."}spawn directive: spawn the specified agent with the provided task promptcomplete directive: mark the chain done, proceed to Phase 7 when all chains completeescalate directive: report to user with the escalation reason; do not attempt to fix the chain manuallycomplete directives from the runtimeBoth 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.
Finalize the feature by committing to git and updating project memory. This phase is triggered when the runtime issues complete directives for all WRFC chains from Phases 2-5.
Create git commit:
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>Update goodvibes memory:
.goodvibes/memory/patterns.json (if new patterns emerged).goodvibes/memory/decisions.json (if new decisions made)goodvibes-memory skillUpdate goodvibes logs:
.goodvibes/logs/tasks.jsonlgoodvibes-memory skillReport to user:
Vibecoding: Confirm commit message with user before committing. Justvibes: Auto-commit with generated message.
Vibecoding mode is collaborative. The orchestrator:
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 typescheckpoint: core implementationcheckpoint: integrationcheckpoint: quality checksJustvibes mode is autonomous. The orchestrator:
The runtime engine manages all WRFC cycles in both modes identically.
Phases 2, 4, 7 must be sequential:
complete directives for all chainsPhases 3 and 5 spawn multiple agents in parallel:
All agents in a parallel phase must receive complete directives before proceeding to the next phase.
Agents should NOT communicate directly. Instead:
All work agents must follow the GPA loop:
discover tool to run parallel grep/glob/symbol queriesSee gather-plan-apply skill for details.
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.
Use goodvibes-memory skill to:
.goodvibes/memory/{decisions,patterns,failures}.json in Phase 1.goodvibes/logs/tasks.jsonl in Phase 7Do not spawn work agents until Phase 1 is complete. Clarify requirements first.
Do not run Phases 2 and 3 in parallel. Phase 3 depends on Phase 2 types.
Do not skip Phase 5. Tests are not optional. Security is not optional.
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.
Do not defer, reorder, or skip <gv> directives. Execute them immediately as the first action when received.
Do not commit in Phase 7 until all WRFC chains have received complete directives. Partial completions are not done.
Do not skip memory updates in Phase 7. Future agents rely on this context.
Use scripts/validate-feature-workflow.sh to verify your orchestration follows this workflow. See references/phase-templates.md for detailed templates and examples.
Activates when the user asks about AI prompts, needs prompt templates, wants to search for prompts, or mentions prompts.chat. Use for discovering, retrieving, and improving prompts.
Search, retrieve, and install Agent Skills from the prompts.chat registry using MCP tools. Use when the user asks to find skills, browse skill catalogs, install a skill for Claude, or extend Claude's capabilities with reusable AI agent components.
Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.