Pamacea Smite Build

Build Skill - Unified Agent v3.1

Mission

Provide ONE unified implementation entry point with:

• 12 composable flags for maximum flexibility
• Auto-detection for zero-configuration usage
• Memory integration for continuous improvement
• Progress tracking for transparent workflow
• Quality metrics for objective validation
• Legacy compatibility for smooth migration

Scope Definition

This skill is designed for:

• Building new features
• Implementing functionality
• Creating components
• Adding APIs
• Developing modules

Use alternative skills for:

Preferred Tools

Always use these tools for their intended purpose:

Tool Selection Decision Tree:

Need to search code?
  ├─ Semantic understanding needed? → grepai search or /toolkit search
  └─ Simple pattern matching? → Grep tool

Need to implement?
  └─ /studio build [flags] "task"

Need to read files?
  └─ Read tool (never cat/head/tail)

Execution Protocol

Phase 1: EXPLORE (Always First)

Mandatory first step for all implementations:

• Execute grepai search or /toolkit search to find existing implementations
• Review related code patterns
• Identify reusable components
• Understand project structure
• Verify library versions (post-2024 libs require web search verification)

Output: Investigation summary with relevant files and patterns

Phase 2: PLAN (Strategy)

• Define implementation approach
• List files to modify/create
• Identify edge cases
• Plan testing strategy
• Estimate complexity

Output: Step-by-step implementation plan

Phase 3: CODE (Implementation)

• Follow existing code patterns exactly
• Use barrel exports (index.ts per folder)
• Write self-documenting code
• Apply delete-first philosophy when appropriate
• Implement with proper TypeScript types

Output: Working implementation following project conventions

Phase 4: TEST (Validation)

• Run linting and type checking
• Execute relevant tests
• Verify no regressions
• Check quality gates (based on flags)
• Measure coverage when applicable

Output: Validation report with quality metrics

Quality Gates

All implementations MUST include:

• Proper TypeScript types (no any, use unknown or proper types)
• Barrel exports in each folder (index.ts)
• Following existing code patterns exactly
• Self-documenting names (no excessive comments)
• Error handling at system boundaries
• Tests for behavior (not implementation details)
• No obvious security vulnerabilities

Additional gates based on flags:

Success Metrics

Objective measurements after each build:

Code Quality Report
════════════════════════════════════════
Lines Added:        [count]
Lines Removed:      [count]
Net Change:         [delta]
Files Touched:      [count]

Barrel Exports:     [all proper/partial/missing]
Type Coverage:      [percentage]%
Test Coverage:      [percentage]%
Complexity:         [reduced/unchanged/increased]

Debt:               [lines improved/added]
Performance:        [measured improvement/not applicable]

Memory:             [patterns saved count]
Documentation:      [generated files]

Status:             [READY FOR MERGE/NEEDS ATTENTION]
════════════════════════════════════════

Flag Quick Reference

Core Flags (v2.0)

Extended Flags (v3.0)

Auto-Detection System

When no flags are provided, the system analyzes the task:

Flag Combinations

Power Combinations:

Memory Integration

After each build, automatically save to claude-mem:

Auto-Save Triggers:

• New pattern discovered
• Architecture decision made
• Convention established
• Bug solution found
• Refactoring technique applied

Usage:

# Search memory before implementing
"Let me check claude-mem for similar patterns first"

# Save after solving
"Saving successful pattern to claude-mem for future reference"

Decision Guide

Need to implement?
- Simple fix / small feature? -> --speed
- Complex / multi-file? -> --scale
- Quality-critical / security? -> --quality
- Large project / multi-domain? -> --team
- Refactoring / cleanup? -> --clean
- Test-critical feature? -> --test
- Bug fixing? -> --debug
- Public API / library? -> --docs
- Performance issue? -> --profile
- Type safety issues? -> --types
- Working with Git? -> --git
- Branch-specific workflow? -> --branch
- Not sure? -> (auto-detect)

Integration with Other Skills

Requires:

• semantic-search - For EXPLORE phase
• memory-integration - For saving patterns

Complements:

• refactor - Use after implementation for cleanup
• multi-review - Use for comprehensive code review
• pattern-capture - Use after successful implementation

Used by:

• All smite workflows as primary implementation entry point

Legacy Compatibility

Deprecated commands (still work):

See Also

Full documentation: @REFERENCE.md

Complete flag details, workflow examples, and advanced combinations:

• Detailed flag workflows (--clean, --test, --debug, --docs, etc.)
• Subagent auto-activation
• Branch-based auto-detection
• Progress tracking patterns
• Best practices checklist
• Technical subagents by tech stack

Build Skill v3.1.0 - Positive engineering with 12-flag system

Converted and distributed by TomeVault — claim your Tome and manage your conversions.