sc-implement
Feature implementation with intelligent persona activation, task orchestration, and MCP integration. Use when implementing features, APIs, components, services, or coordinating multi-agent development. Triggers on requests for code implementation, feature development, or complex task orchestration.
When & Why to Use This Skill
The sc-implement skill is an advanced agentic development framework designed for end-to-end feature implementation. It leverages intelligent persona activation—coordinating specialized roles like Architect, Security, and QA—to build robust APIs, UI components, and backend services. By integrating Model Context Protocol (MCP) tools and iterative learning loops, it ensures high-quality code delivery that adheres to KISS and Purity principles while automating complex task orchestration.
Use Cases
- Full-Stack Feature Development: Orchestrating multiple AI personas to simultaneously build React components and Express services with framework-specific best practices.
- Automated API Engineering: Generating secure, tested, and documented RESTful or GraphQL APIs with built-in validation and security guardrails.
- Complex System Orchestration: Managing large-scale architectural changes by breaking down tasks into hierarchical steps and using multi-model consensus for decision-making.
- Continuous Quality Improvement: Utilizing iterative 'Loop Mode' to refine code based on automated reviews, debugging findings, and learned patterns from previous sessions.
| name | sc-implement |
|---|---|
| description | Feature implementation with intelligent persona activation, task orchestration, and MCP integration. Use when implementing features, APIs, components, services, or coordinating multi-agent development. Triggers on requests for code implementation, feature development, or complex task orchestration. |
Implementation Skill
Comprehensive feature implementation with coordinated expertise and systematic development.
Quick Start
# Basic implementation
/sc:implement [feature-description] --type component|api|service|feature
# With framework
/sc:implement dashboard widget --framework react|vue|express
# Complex orchestration
/sc:implement [task] --orchestrate --strategy systematic|agile|enterprise
Behavioral Flow
- Analyze - Examine requirements, detect technology context
- Plan - Choose approach, activate relevant personas
- Generate - Create implementation with framework best practices
- Validate - Apply security, quality, and principles validation
- Run KISS validation:
python .claude/skills/sc-principles/scripts/validate_kiss.py --scope-root . --json - Run Purity validation:
python .claude/skills/sc-principles/scripts/validate_purity.py --scope-root . --json - If blocked: Refactor code to comply before proceeding
- Run KISS validation:
- Integrate - Update docs, provide testing recommendations
Flags
| Flag | Type | Default | Description |
|---|---|---|---|
--type |
string | feature | component, api, service, feature |
--framework |
string | auto | react, vue, express, etc. |
--safe |
bool | false | Enable safety constraints |
--with-tests |
bool | false | Generate tests alongside code |
--fast-codex |
bool | false | Streamlined path, skip multi-persona |
--orchestrate |
bool | false | Enable hierarchical task breakdown |
--strategy |
string | systematic | systematic, agile, enterprise, parallel, adaptive |
--delegate |
bool | false | Enable intelligent delegation |
--principles |
bool | true | Enable KISS/Purity validation |
--strict-principles |
bool | false | Treat principles warnings as errors |
Personas Activated
- architect - System design, architectural decisions
- frontend - UI/component implementation
- backend - API/service implementation
- security - Security validation, auth concerns
- qa-specialist - Testing, quality assurance
- devops - Infrastructure, deployment
- project-manager - Task coordination (with --orchestrate)
- code-warden - Principles enforcement (KISS, Purity)
MCP Integration
PAL MCP (Always Use for Quality)
| Tool | When to Use | Purpose |
|---|---|---|
mcp__pal__consensus |
Architectural decisions | Multi-model validation before major changes |
mcp__pal__codereview |
Code quality | Review implementation quality, security, performance |
mcp__pal__precommit |
Before commit | Validate all changes before git commit |
mcp__pal__debug |
Implementation issues | Root cause analysis for bugs encountered |
mcp__pal__thinkdeep |
Complex features | Multi-stage analysis for complex implementations |
mcp__pal__planner |
Large features | Sequential planning for multi-step implementations |
mcp__pal__apilookup |
Dependencies | Get current API/SDK documentation |
mcp__pal__challenge |
Code review feedback | Critically evaluate review suggestions |
PAL Usage Patterns
# Consensus for architectural decision
mcp__pal__consensus(
models=[
{"model": "gpt-5.2", "stance": "for"},
{"model": "gemini-3-pro", "stance": "against"},
{"model": "deepseek", "stance": "neutral"}
],
step="Evaluate: Should we use Redux or Context API for state management?"
)
# Pre-commit validation
mcp__pal__precommit(
path="/path/to/repo",
step="Validating implementation changes",
findings="Security, performance, completeness checks",
confidence="high"
)
# Code review after implementation
mcp__pal__codereview(
review_type="full",
step="Reviewing new authentication implementation",
findings="Quality, security, performance, architecture",
relevant_files=["/src/auth/login.ts", "/src/auth/middleware.ts"]
)
# Debug implementation issue
mcp__pal__debug(
step="Investigating why API returns 500 on edge case",
hypothesis="Null check missing for optional field",
confidence="medium"
)
Rube MCP (Automation & Integration)
| Tool | When to Use | Purpose |
|---|---|---|
mcp__rube__RUBE_SEARCH_TOOLS |
External services | Find APIs, SDKs, integrations |
mcp__rube__RUBE_MULTI_EXECUTE_TOOL |
CI/CD, notifications | Trigger builds, notify team, update tickets |
mcp__rube__RUBE_REMOTE_WORKBENCH |
Code generation | Bulk code operations, transformations |
mcp__rube__RUBE_CREATE_UPDATE_RECIPE |
Reusable workflows | Save implementation patterns as recipes |
mcp__rube__RUBE_MANAGE_CONNECTIONS |
Verify integrations | Ensure external service connections |
Rube Usage Patterns
# Search for integration tools
mcp__rube__RUBE_SEARCH_TOOLS(queries=[
{"use_case": "send slack message", "known_fields": "channel_name:dev-updates"},
{"use_case": "create github pull request", "known_fields": "repo:myapp"}
])
# Notify team and update ticket on completion
mcp__rube__RUBE_MULTI_EXECUTE_TOOL(tools=[
{"tool_slug": "SLACK_SEND_MESSAGE", "arguments": {
"channel": "#dev-updates",
"text": "Feature implemented: User authentication flow"
}},
{"tool_slug": "JIRA_UPDATE_ISSUE", "arguments": {
"issue_key": "PROJ-123",
"status": "In Review"
}},
{"tool_slug": "GITHUB_CREATE_PULL_REQUEST", "arguments": {
"repo": "myapp",
"title": "feat: Add user authentication",
"base": "main",
"head": "feature/auth"
}}
])
# Save implementation workflow as recipe
mcp__rube__RUBE_CREATE_UPDATE_RECIPE(
name="Feature Implementation Workflow",
description="Standard flow for implementing features with notifications",
workflow_code="..."
)
MCP-Powered Loop Mode
When --loop is enabled, MCP tools are used between iterations:
- Iteration N - Implement feature
- PAL codereview - Assess quality (target: 70+ score)
- PAL debug - Investigate any issues found
- Iteration N+1 - Apply improvements
- PAL precommit - Final validation before marking complete
Guardrails
- Start in analysis mode; produce scoped plan before touching files
- Only mark complete when referencing concrete repo changes (filenames + diff hunks)
- Return plan + next actions if tooling unavailable
- Prefer minimal viable change; skip speculative scaffolding
- Escalate to security persona before modifying auth/secrets/permissions
Evidence Requirements
This skill requires evidence. You MUST:
- Show actual file diffs or code changes
- Reference test results or lint output
- Never claim code exists without proof
Examples
React Component
/sc:implement user profile component --type component --framework react
API with Tests
/sc:implement user auth API --type api --safe --with-tests
Complex Orchestration
/sc:implement "enterprise auth system" --orchestrate --strategy systematic --delegate
Loop Mode & Learning
When using --loop, this skill integrates with the skill persistence layer for cross-session learning:
How Learning Works
- Feedback Recording - Each iteration's quality scores and improvements are persisted
- Skill Extraction - Successful patterns are extracted when quality threshold is met
- Skill Retrieval - Relevant learned skills are injected into subsequent tasks
- Effectiveness Tracking - Applied skills are tracked for success rate
Loop Flags
| Flag | Type | Default | Description |
|---|---|---|---|
--loop |
int | 3 | Enable iterative improvement (max 5) |
--learn |
bool | true | Enable learning from this session |
--auto-promote |
bool | false | Auto-promote high-quality skills |
Example with Learning
# Iterative implementation with learning
/sc:implement auth flow --loop 3 --learn
# View learned skills
python scripts/skill_learn.py '{"command": "stats"}'
# Retrieve relevant skills
python scripts/skill_learn.py '{"command": "retrieve", "task": "auth"}'
Learned Skills Location
Promoted skills are stored in:
.claude/skills/learned/
├── SKILL.md # Index
├── learned-backend-auth/ # Example promoted skill
│ ├── SKILL.md
│ └── metadata.json
Resources
- PERSONAS.md - Available persona definitions
- scripts/select_agent.py - Agent selection logic
- scripts/evidence_gate.py - Evidence validation
- scripts/skill_learn.py - Skill learning management