prodige-workflow

Communicate efficiently without sacrificing clarity - natural, concise, actionable. Global skill loaded for every command and agent.

Use when reviewing or building UI components - ensures keyboard, screen-reader, and visual accessibility (WCAG 2.1 AA) so a11y is built in, not retrofitted.

You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.

Manages context caching to optimize token usage and cost by creating, incrementally updating, and invalidating caches while verifying integrity before reuse.

Clean code and engineering discipline: modularity, readability, sizing, naming, duplication, separation of concerns, plus the four behavioral principles - think before coding, simplicity first, surgical changes, and goal-driven execution. Global skill applied to all coding work.

Detects and resolves drift between code, documentation, and contextual knowledge, classifying each drift and recommending concrete sync actions to keep artifacts consistent.

Detects and quantifies technical, knowledge, architecture, documentation, and testing debt; rates severity and produces a prioritized paydown plan in time/risk/money terms.

Audits project dependencies for security vulnerabilities, license compliance, version conflicts, unused packages, and lockfile integrity. Owns supply-chain analysis (security-review defers here).

Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies

Maintains accurate, up-to-date project documentation (README, API docs, changelogs, ADRs, knowledge) by comparing docs against code reality and recommending specific updates.

Use when you have a written implementation plan to execute sequentially (fallback when subagent-driven-development not available)

Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work through Prodige's Release Gate by presenting structured options for merge, PR, or cleanup

Creates and validates comprehensive handoff documentation capturing context, decisions, files affected, and next steps for seamless continuity across sessions and agents.

Translates approved designs into safe, modular, testable implementation plans with ordered phases, dependency mapping, risk mitigation, and verification checkpoints.

Prevents parallel agents from editing conflicting resources through intelligent lock coordination and conflict detection.

Token-optimized retrieval from the Memory Bank. Use when asked 'did we solve this before?', 'how did we do X last time?', or when resuming work and you need prior-session context WITHOUT reading every memory file.

Analyzes work and splits it into safe, independent parallel agent sessions to maximize throughput without conflicts.

Use when reviewing code in hot paths, data-heavy operations, or user-facing latency-sensitive features - detects algorithmic, query, memory, and frontend performance issues before they regress production.

Synthesize a narrative project-history report (evolution, decisions, debugging arcs, ROI) from the Memory Bank. Use when asked for a project history, development journey, retrospective, or 'what's the story of this project?'.

Reality check for requirements and plans: identifies assumptions, ambiguities, missing requirements, and hidden risks before implementation.

Creates concise, hierarchical maps of repository structure showing entrypoints, modules, critical files, and their relationships.

Use when completing tasks, implementing major features, or before merging to verify work meets requirements

Enforces disciplined decision-making: prefer reuse, then refactor, then rebuild only with strong justification.

Use at the start of a review to load codebase-specific recurring-issue patterns, and after a review to record new findings - makes the reviewer get smarter about THIS codebase over time.

Enforces search-before-coding discipline: never create new implementation before checking existing code patterns and utilities.

Comprehensive security assessment: checks for exposed secrets, authentication/authorization flaws, injection vulnerabilities, unsafe dependencies, and data exposure risks.

Creates and manages stable context snapshots for parallel agent work, ensuring consistent starting points and preventing race conditions.

Use when executing implementation plans with independent tasks in the current session

Disciplined 6-phase debugging for hard bugs, performance regressions, and systematic root cause analysis. Build feedback loop → reproduce → analyze → hypothesize → fix → cleanup. Mandatory for all bug fixes. Use when debugging, fixing bugs, or investigating failures.

Test-driven development with red-green-refactor discipline. Tests verify behavior through public interfaces, not implementation. Use when building features, fixing bugs, or refactoring code. Mandatory for all production code.

Identifies comprehensive test cases, regression scenarios, and edge cases to ensure thorough test coverage and prevent bugs.

Use when creating new Prodige skills, editing existing skills, or verifying skills work before deployment - applies TDD methodology to process documentation

Brutally honest critique of code and architecture: overengineering, security flaws, maintainability issues, poor UX, and scalability problems.

Design interview that challenges plans against domain model and documented decisions. Sharpens terminology, stress-tests scenarios, and updates CONTEXT.md and ADRs inline. Use before /design or /build to validate requirements and align on vocabulary.

Use when receiving code review feedback, before implementing suggestions - requires technical rigor and verification, not performative agreement

Use when starting feature work that needs isolation OR before parallel execution - ensures isolated workspace via native tools or git worktree fallback