Awesome Copilot Indonesia 🇮🇩 - AI Agents & SDLC Workflows

A curated collection of custom agents, skills, rules, and prompts for AI-assisted development, specifically tailored for Indonesian developers and development workflows. This collection uses a Single Source of Truth architecture: all agent configurations live in the .agents/ directory and are automatically mapped to platform-specific folders during installation. Supported platforms include GitHub Copilot, Google Antigravity, OpenCode, CommandCode, ChatGPT Codex, Pi Dev Coding Agent, Oh My Pi (omp), Claude Code, and Cursor. The SDLC workflows are heavily inspired by the GitHub Spec Kit, with additional enhancements and refinements.

📋 Overview

This repository provides two complete, production-ready AI SDLC methodology packages designed for modern software engineering:

1. 📦 Standard SDLC Package (.agents/ & root AGENTS.md):

   • Full 12-phase SDLC pipeline (/sdlc-*) inspired by GitHub Spec Kit.
   • Heavy lifting PRD bypass, Tracer-Bullet task planning, and surgical code modifications.
   • Rich supplementary skills (code-janitor, omni-dev, ui-designer, guided-learning, fable-protocol).

2. 🧪 TDD-Spec SDLC Package (tdd-spec-skills/ & tdd-spec-skills/AGENTS.md):

   • 21 specialized skills (/tdd-*) enforcing strict Test-Driven Development (TDD), Behavior-Driven Development (BDD), and Contract-First Architecture.
   • Living Architecture Maps (docs/ARCHITECTURE.md), Pre-Agreed Test Seams, and Floor-Guard anti-cheat enforcement.
   • Interactive project navigator and AI guide (/tdd-ask-help) inspired by ask-matt.

• 🔌 Multi-Platform: A Single Source of Truth architecture automatically installed to .agents/ (GitHub Copilot, Antigravity, OpenCode, CommandCode, Codex, Pi, OMP), .claude/ (Claude Code), or .cursor/ (Cursor).
• 🔑 BYOK Copilot Config: Ready-to-use chatLanguageModels.json template for bringing your own API keys to VS Code Copilot chat.

📑 Table of Contents

• Overview
• Getting Started
  • Prerequisites
  • Installation
• Custom Agents (Standard SDLC)
• Skills
• Workflow & Methodology (Standard SDLC)
• TDD-Spec SDLC Package (Test-First & Spec Kit)
• Supplementary Skills
• BYOK Copilot Config
• Advanced Customization Guide
• Contributing
• Resources
• Support
• License

🚀 Getting Started

Prerequisites

• An AI Assistant platform of your choice:
  • GitHub Copilot (Individual, Business, or Enterprise)
  • Google Antigravity
  • OpenCode
  • CommandCode
  • ChatGPT Codex
  • Pi Dev Coding Agent (pi.dev)
  • Oh My Pi (omp) (omp.sh)
  • Claude Code
  • Cursor

Installation

Choose from Agentic (npx skills), Automated Script, or Manual installation methods:

Method 1: Agentic Installation via npx skills (Recommended for AI Agents)

Install the bootstrapper skill directly using the npx skills CLI into your project (works with Google Antigravity, Cursor, Claude Code, GitHub Copilot, OpenCode, Codex, Pi, and OMP):

📦 Option A: Standard SDLC Package (12 Phases)

Installs the full 12-phase SDLC pipeline (/sdlc-*) with supplementary engineering skills:

# Using GitHub Shorthand (Short & Recommended)
npx skills add GulajavaMinistudio/awesome-copilot-id/.agents/skills/sdlc-init

# Or using full GitHub URL
npx skills add https://github.com/GulajavaMinistudio/awesome-copilot-id/tree/main/.agents/skills/sdlc-init

Then in your AI Assistant chat window, run:

/sdlc-init setup this project

The bootstrapper agent will autonomously download AGENTS.md and .agents/ configuration, preserve existing memory files, merge global rules, and set up your project.

🧪 Option B: TDD-Spec SDLC Package (21 Skills)

Installs the test-first engineering suite (/tdd-*) with Living Architecture Maps, Pre-Agreed Test Seams, and Floor-Guard anti-cheat enforcement:

# Using GitHub Shorthand (Short & Recommended)
npx skills add GulajavaMinistudio/awesome-copilot-id/tdd-spec-skills/.agents/skills/tdd-init

# Or using full GitHub URL
npx skills add https://github.com/GulajavaMinistudio/awesome-copilot-id/tree/main/tdd-spec-skills/.agents/skills/tdd-init

Then in your AI Assistant chat window, run:

/tdd-init setup this project

The bootstrapper agent will initialize project governance (CONSTITUTION.md, CONSTRAINTS.md, AGENTS.md), auto-map the existing codebase architecture into docs/ARCHITECTURE.md, and configure all 21 TDD skills.

Method 2: Automated Installation (One-Liner)

Run the following command in your terminal inside your project root directory:

• Linux / macOS (Bash/Zsh):

  curl -fsSL https://raw.githubusercontent.com/GulajavaMinistudio/awesome-copilot-id/main/install.sh | bash
  

• Windows Terminal (PowerShell):

  irm https://raw.githubusercontent.com/GulajavaMinistudio/awesome-copilot-id/main/install.ps1 | iex
  

The interactive script will download the repository, prompt you to choose your desired SDLC Package and target Platform, copy the configuration to the correct destination directory (.agents/, .claude/, or .cursor/), and safely handle existing configuration files (such as memory.instructions.md and AGENTS.md) by offering options to keep, replace, or merge them.

The installer offers these package & platform choices:

Step 1: SDLC Package Selection

Step 2: Platform Selection

Method 3: Manual Installation

1. Clone this repository:

   git clone https://github.com/GulajavaMinistudio/awesome-copilot-id.git
   

2. Choose your desired SDLC Package and copy the configuration:

   For Standard SDLC Package (.agents/):

   # Standard Platforms: copy .agents/ directly
   cp -r awesome-copilot-id/.agents ./
   cp awesome-copilot-id/AGENTS.md ./
   
   # Claude Code: copy contents of .agents/ into .claude/
   mkdir -p .claude && cp -a awesome-copilot-id/.agents/. .claude/
   cp awesome-copilot-id/AGENTS.md ./
   
   # Cursor: copy contents of .agents/ into .cursor/
   mkdir -p .cursor && cp -a awesome-copilot-id/.agents/. .cursor/
   cp awesome-copilot-id/AGENTS.md ./
   

   For TDD-Spec SDLC Package (tdd-spec-skills/):

   # Standard Platforms: copy tdd-spec-skills/.agents/ directly
   cp -r awesome-copilot-id/tdd-spec-skills/.agents ./
   cp awesome-copilot-id/tdd-spec-skills/AGENTS.md ./
   
   # Claude Code: copy contents of tdd-spec-skills/.agents/ into .claude/
   mkdir -p .claude && cp -a awesome-copilot-id/tdd-spec-skills/.agents/. .claude/
   cp awesome-copilot-id/tdd-spec-skills/AGENTS.md ./
   
   # Cursor: copy contents of tdd-spec-skills/.agents/ into .cursor/
   mkdir -p .cursor && cp -a awesome-copilot-id/tdd-spec-skills/.agents/. .cursor/
   cp awesome-copilot-id/tdd-spec-skills/AGENTS.md ./
   

   [!IMPORTANT] After copying AGENTS.md, you must open it and update the first line (# AGENTS.md - [Your Application Name]) to match your actual project's context, as well as the [Project Description] placeholder (if present). You can also adjust the language preferences in the ## Communication section as needed.

3. Restart your IDE or AI assistant to apply the changes.

[!TIP] You can also reference these files from a central location in your system and symlink them to your projects for easier management.

🤖 Custom Agents (via SDLC Slash Commands)

Custom agents are specialized AI assistants for specific development roles and tasks. Each agent is activated via a slash command that triggers the corresponding skill. All configurations reside in the .agents/skills/ directory (or the platform-equivalent: .claude/skills/, .cursor/skills/).

[!IMPORTANT] Don't forget to copy AGENTS.md to your project root after copying these agents. This file contains the core SDLC rules that all agents must follow. See Step #3 in Installation for details.

How to Use

Invoke the agent's underlying skill directly using the slash command syntax, and attach the required upstream documents using @filename:

/sdlc-write-code implement the shopping cart based on @plan-shopping-cart.md
/sdlc-code-review review my service layer based on @spec-shopping-cart.md and @plan-shopping-cart.md
/sdlc-draft-prd create a PRD for the user authentication module based on @discovery-draft.md

🤹 Skills

Skills provide agents with specialized capabilities, workflows, and prompts. They are located in the .agents/skills/ directory (or the platform-equivalent: .claude/skills/, .cursor/skills/).

[!IMPORTANT] Don't forget to copy AGENTS.md to your project root after copying these skills. This file contains the core SDLC rules that all agents and skills must follow. See Step #3 in Installation for details.

SDLC Phase Skills (Persona-Bound)

These skills activate a specialized agent persona and lock the session to that phase:

Utility & Supplementary Skills (Cross-Cutting)

These skills can be invoked by any agent at any time without triggering a session lock:

Agent and Skill Configuration File Structure

Agent files use the .md or .agent.md extension depending on the platform, and feature a YAML frontmatter:

---
description: "God Mode Developer - God-Tier Autonomous Engineer with Deep Thinking Protocol."
mode: all
---

Body: Instructions and guidelines for the agent behavior. You can:

• Define specialized instructions for the agent's role
• Specify core directives and interaction philosophies
• Detail how the agent should utilize its assigned skill

🎭 Dynamic Persona Activation (Skill-driven Agents)

In our architecture, skills aren't just passive sets of tools or instructions; they have the power to dynamically transform your base AI assistant into a highly specialized agent persona.

If a skill contains a ## 🎭 Dynamic Persona Activation block in its SKILL.md file, merely invoking that skill will automatically override the default assistant's system prompt and transform it into the specialized agent assigned to that skill.

For example, directly executing the sdlc-draft-prd skill will automatically activate the Product Manager persona and its strict rules, meaning you don't need to separately configure an agent file!

Session Locking & Utility Skills (Cross-Cutting)

To prevent context bleeding and scope creep, our SDLC agents enforce Strict Session Isolation. Once an agent persona (e.g., /sdlc-define-specs) is activated in a chat session, that session is locked to that persona.

However, we have Utility Skills that can be invoked at any time without triggering a session lock clash:

• Persona-Bound Skills: Contain a ## 🎭 Dynamic Persona Activation block in their SKILL.md. Invoking them locks the session. If you try to invoke a different persona-bound skill in the same session, the agent will reject it to maintain focus.
• Utility Skills: Skills without the persona activation block (like grilling, memory-manager, and fable-protocol). These can be invoked freely by any agent in the middle of a session. For example, /sdlc-clarify-reqs can invoke the grilling skill to interrogate a document without losing its analyst persona.

Custom User Skills: Any custom skill you create or download that lacks the Dynamic Persona Activation block will automatically be treated as a Utility Skill and can be freely called at any time.

🔄 Workflow & Methodology (Spec Kit Inspired)

We adopt a strict and structured SDLC workflow, heavily inspired by the GitHub Spec Kit approach. Generally, development must follow a sequential order. The PRD phase can be bypassed if the user provides a comprehensive brief:

• Bootstrap & Scaffolding: Use /sdlc-init to initialize project architecture, rules, and AGENTS.md.
• Architecture Mapping: Use /sdlc-map-architecture to scan repository topography, directory structures, and generate or maintain docs/ARCHITECTURE.md.
• Phase 0: Project Discovery: Use /sdlc-explore-ideas to explore existing codebases, brainstorm architecture, and generate raw drafts for Product Managers.
• Phase PRD: Product Requirements: Use /sdlc-draft-prd to define user stories and acceptance criteria.
• Recurring Checkpoint: Clarification: Use /sdlc-clarify-reqs to interrogate the PRD, Spec, or Plan to resolve ambiguities.
• Phase Spec: Technical Specification: Use /sdlc-define-specs to generate machine-readable technical specs.
• Phase Plan: Implementation Planning: Use /sdlc-plan-tasks to generate executable implementation plans.
• Phase Code: Execution: Use /sdlc-write-code for coding, ensuring strict testing (unit/widget/integration) after every phase.
• Recurring Checkpoint: Artifact Consistency Audit: Use /sdlc-audit-consistency to validate traceability across PRD, Spec, and Plan to prevent scope creep.
• Supplementary: Code Review & Security Audit: Use /sdlc-code-review for code review and security audits. (For bug fixes, use /sdlc-bug-report)
• Supplementary: User Documentation: Use /sdlc-generate-docs for user documentation.
• Supplementary: Ad-hoc Maintenance: Use /code-janitor for quick fixes, cleanups, and minor refactors bypassing the SDLC.

[!IMPORTANT]

• Complete and structured documentation must exist before coding begins.
• Every output must be verified against the PRD and Spec before proceeding.
• We recommend starting a new chat session when switching phases to maintain context focus.

📂 Mandatory Context Injection Protocol

To prevent context loss, hallucinations, and to enforce strict SDLC traceability, you MUST explicitly attach, mention (e.g., using @filename), or provide the required upstream documents in the prompt context when invoking an agent. You are also highly encouraged to include other relevant files or code snippets to complete the analysis.

If the mandatory files are not provided in the prompt context, the agent will halt execution and ask you to provide them.

Note: Phase 0 (/sdlc-explore-ideas) and surgical bug analysis (/sdlc-bug-report) rely on user briefs, codebase exploration, or bug reports, and do not have strictly enforced upstream SDLC documents, though providing relevant context is highly encouraged.

Note: For minor fixes, refactoring, and ad-hoc tasks, the mandatory document check can be fast-tracked. Agents proactively offer this fast-track option to the user to proceed without full SDLC ceremony.

🎯 Use Cases

End-to-End Feature Development (SDLC Workflow)

Following our strict sequential workflow, here is how you would develop a new feature:

Pre-Phase: Architecture Mapping & Topography

/sdlc-map-architecture map repository architecture to docs/ARCHITECTURE.md

(Run this to document repository topology, directory purposes, and runtime architecture into docs/ARCHITECTURE.md before planning new features)

Phase 0: Project Discovery

/sdlc-explore-ideas explore the codebase and write a discovery draft for the new shopping cart feature based on @business-brief.md

(Note: @business-brief.md is a placeholder for any human-written file provided by you, such as raw meeting notes, client requirements, or a simple text file with your ideas. Once the Discovery Draft is finalized, use memory-manager to save context, then open a new chat session)

Phase PRD: Requirements & Clarification

/sdlc-draft-prd create a PRD for the shopping cart feature based on @discovery-draft.md

(Once the PRD is complete and approved, use the memory-manager skill to save context, then open a new chat session to prevent context bleeding)

Recurring Checkpoint: Clarification (Optional)

/sdlc-clarify-reqs interrogate the new @prd-shopping-cart.md for missing edge cases

(Answer the Clarification Analyst's questions one by one. Once finished and the PRD is revised, use memory-manager to save context, then proceed to the Spec phase in a new chat session)

Phase Spec: Technical Specification

# Option 1: Standard (Based on PRD)
/sdlc-define-specs design a technical specification based on @prd-shopping-cart.md

# Option 2: PRD Bypass (Based on Brief/Discovery)
/sdlc-define-specs design a tech spec based on @discovery-draft.md. Do heavy lifting to guess missing technical details and mark them as [ASSUMPTION].

# Option 3: Direct Prompt (No upstream document)
/sdlc-define-specs design a tech spec for a real-time chat feature using React and Node.js. Do heavy lifting for any missing details.

(Once the Spec is complete, use memory-manager and open a new chat session)

Recurring Checkpoint: Clarification (Optional)

/sdlc-clarify-reqs interrogate the new @spec-shopping-cart.md for any technical ambiguities

(Once the Spec interrogation is finalized, use memory-manager and open a new chat session)

Recurring Checkpoint: Consistency Audit (Optional)

/sdlc-audit-consistency verify that @spec-shopping-cart.md covers all requirements in @prd-shopping-cart.md

(If no PRD requirements are missing from the Spec, use memory-manager and open a new chat session)

Phase Plan: Implementation Planning

# Option 1: Standard (Based on Spec)
/sdlc-plan-tasks create a step-by-step implementation plan based on @spec-shopping-cart.md

# Option 2: With Assumption Scanning (Recommended for PRD Bypass)
/sdlc-plan-tasks create an implementation plan based on @spec-shopping-cart.md. Extract any [ASSUMPTION] tags into the Risks & Assumptions section and label related tasks as [High Risk].

(Once the Plan is created, use memory-manager and open a new chat session)

Recurring Checkpoint: Clarification (Optional)

/sdlc-clarify-reqs interrogate the @plan-shopping-cart.md for any unhandled edge cases

(Once all edge cases in the Plan are addressed, use memory-manager to save context, then open a new chat session to begin coding)

Phase Code: Implementation & Review

/sdlc-write-code implement the shopping cart based on @plan-shopping-cart.md, and ensure all tests pass

(Once code implementation and testing are complete, use memory-manager and open a new chat session)

/sdlc-code-review review the newly implemented service layer and suggest refactoring

(Apply any refactoring suggestions if needed, use memory-manager to save context, then open a new chat session for documentation)

Supplementary: Documentation & Bug Fixing

/sdlc-generate-docs write an API reference guide based on @spec-shopping-cart.md and @cart.js

(If bugs are discovered later, use the specialized bug remediation agent in a separate chat session)

/sdlc-bug-report analyze the bug report in @issue-123.md and propose a fix for @cart.js

Minor Fixes & Ad-hoc Tasks (SDLC Bypass)

For small, surgical tasks (like renaming a function, tweaking CSS, or fixing a typo), forcing the full SDLC (PRD -> Spec -> Plan -> Code) is inefficient. You can use the "escape hatch" to bypass the SDLC protocol by explicitly telling the agent.

Example Prompt for Minor Tasks:

/sdlc-write-code This is a minor fix. Please refactor the `calculateTotal` function in @cart.js to be more concise, and add some padding to the `.btn-checkout` class in @style.css.

Note: Even when bypassing the SDLC, you are still highly encouraged to attach the specific source code files (e.g., @cart.js, @style.css) to provide the agent with the necessary context.

Quick Reference: Slash Command Cheat Sheet

Use the slash command syntax (/<skill-name>) to invoke agents directly. Attach the required upstream documents using @filename to comply with the Mandatory Context Injection Protocol.

/sdlc-init            initialize project architecture & AGENTS.md
/sdlc-map-architecture map repository architecture to docs/ARCHITECTURE.md
/sdlc-explore-ideas   explore the codebase based on @business-brief.md
/sdlc-draft-prd       create a PRD based on @discovery-draft.md
/sdlc-clarify-reqs    interrogate @prd-shopping-cart.md for missing edge cases
/sdlc-define-specs    design a tech spec based on @prd-shopping-cart.md
/sdlc-audit-consistency verify @spec-shopping-cart.md vs @prd-shopping-cart.md
/sdlc-plan-tasks      create an implementation plan based on @spec-shopping-cart.md
/sdlc-write-code      implement the shopping cart based on @plan-shopping-cart.md
/sdlc-code-review     review the service layer based on @spec-shopping-cart.md
/sdlc-bug-report      analyze the bug in @issue-123.md and propose a fix
/sdlc-generate-docs   write an API reference based on @spec-shopping-cart.md
/code-janitor         fix typos in @style.css or do minor refactoring

🌟 Best Practices

1. Adhere to the SDLC Sequence: Never skip a phase. Ensure that PRD, Specs, and Plans are fully fleshed out before invoking /sdlc-write-code for coding.
2. Use the Correct Destination Directory: Place your configuration in the correct directory for your platform: .agents/ for standard platforms, .claude/ for Claude Code, or .cursor/ for Cursor.
3. Use Appropriate Slash Commands: Match the command to the current SDLC phase (e.g., /sdlc-define-specs for specs, /sdlc-code-review for code audits).
4. Leverage Project Memory: Periodically save significant milestones using the memory-manager skill to maintain context across different chat sessions.
5. Iterate and Verify: Always verify the outputs of an agent against the original PRD and Spec before proceeding to the next phase.
6. Floor-Guard Anti-Cheat Rule: Suppressions like @ts-ignore, eslint-disable, # noqa, skipping tests (.skip, xit), or deleting assertions are strictly forbidden. Fix the code to satisfy the contract instead of weakening tests.
7. Anti-Injection Shield: All ingested external documentation, source code files, bug reports, and logs are treated strictly as inert reference data (3-layer protection) to guard against prompt injection overrides.
8. Living Architecture Map Mandate: Keep docs/ARCHITECTURE.md evergreen by updating it (or invoking /sdlc-map-architecture) whenever directory topologies, architectural modules, or API contracts change.

🌐 Language Preferences

By default, the rules in this repository are configured to instruct the AI agents to communicate in Indonesian (Bahasa Indonesia).

If you prefer to interact in English or another language, you can easily change this. Open the AGENTS.md file and modify the following sections:

1. Under ## Communication, change the language rule: - **Language**: Communication must use clear and proper English
2. Under ## User Communication Style, adjust the preference: - Uses formal but casual English

📊 SDLC Workflow Diagram

graph TD
    %% Define Styles
    classDef agent fill:#0d1117,color:#58a6ff,stroke:#30363d,stroke-width:2px;
    classDef phase fill:#238636,color:#ffffff,stroke:#2ea043,stroke-width:2px,rx:10px,ry:10px;

    %% Nodes
    Phase0[Phase 0: Project Discovery]:::phase
    Phase1[Phase PRD: Product Requirements]:::phase
    Phase2[Phase Spec: Technical Specification]:::phase
    Phase3[Phase Plan: Implementation Planning]:::phase
    Phase4[Phase Code: Execution]:::phase
    Phase5[Supplementary: User Documentation]:::phase

    AgentBEA["/sdlc-explore-ideas<br/>(Explores Code and Brainstorms)"]:::agent
    AgentPM["/sdlc-draft-prd<br/>(Creates PRD)"]:::agent
    AgentCA1["/sdlc-clarify-reqs<br/>(Interrogates PRD)"]:::agent

    AgentSA["/sdlc-define-specs<br/>(Creates Tech Spec)"]:::agent
    AgentCA2["/sdlc-clarify-reqs<br/>(Interrogates Spec)"]:::agent
    AgentACC["/sdlc-audit-consistency<br/>(Validates Traceability)"]:::agent

    AgentPA["/sdlc-plan-tasks<br/>(Creates Implementation Plan)"]:::agent
    AgentCA3["/sdlc-clarify-reqs<br/>(Interrogates Plan)"]:::agent

    AgentGMD["/sdlc-write-code<br/>(Writes Code and Tests)"]:::agent
    AgentECR["/sdlc-code-review<br/>(Audits Code)"]:::agent
    AgentBRA["/sdlc-bug-report<br/>(Fixes Bugs)"]:::agent

    AgentDDA["/sdlc-generate-docs<br/>(Writes User Docs)"]:::agent

    %% Flow
    Phase0 --> AgentBEA
    AgentBEA --> Phase1

    Phase1 --> AgentPM
    AgentPM --> AgentCA1
    AgentCA1 --> Phase2

    Phase2 --> AgentSA
    AgentSA --> AgentCA2
    AgentCA2 --> AgentACC
    AgentACC --> Phase3

    Phase3 --> AgentPA
    AgentPA --> AgentCA3
    AgentCA3 --> Phase4

    Phase4 --> AgentGMD
    AgentGMD --> AgentECR
    AgentECR -.-> |If issues/bugs| AgentBRA
    AgentBRA -.-> AgentGMD
    AgentECR --> Phase5

    Phase5 --> AgentDDA

Text-based Alternative (Fallback)

[ Phase 0: Project Discovery ]
          |
          v
  (/sdlc-explore-ideas)
          |
          v
[ Phase PRD: Product Requirements ]
          |
          v
  (/sdlc-draft-prd)
          |
          v
  (/sdlc-clarify-reqs)
     (Interrogate PRD)
          |
          v
[ Phase Spec: Technical Specification ]
          |
          v
  (/sdlc-define-specs)
          |
          v
  (/sdlc-clarify-reqs)
     (Interrogate Spec)
          |
          v
  (/sdlc-audit-consistency)
     (Traceability)
          |
          v
[ Phase Plan: Implementation Planning ]
          |
          v
  (/sdlc-plan-tasks)
          |
          v
  (/sdlc-clarify-reqs)
     (Interrogate Plan)
          |
          v
[ Phase Code: Execution ]
          |
          v
  (/sdlc-write-code) ─────────────────> (/sdlc-code-review)
          ^                                      |
          |                                      | (If bugs/issues)
          |                                      v
          └───────────────────────── (/sdlc-bug-report)
          |
          v
[ Supplementary: User Documentation ]
          |
          v
  (/sdlc-generate-docs)

🧪 TDD-Spec SDLC Package (Test-First & Spec Kit)

📖 Full Documentation: For complete deep-dive documentation, ASCII maps, and individual skill specifications, visit tdd-spec-skills/README.md.

The TDD-Spec SDLC Package is a self-contained suite of 21 specialized skills engineered for teams that require strict Test-Driven Development (TDD), Behavior-Driven Development (BDD), and Contract-First Architecture.

====================================================================================================
                        🧪 TDD-SPEC SDLC COMPLETE PIPELINE TOPOGRAPHY
====================================================================================================
[ Phase -1: BOOTSTRAP & GOVERNANCE ]
    │   └─▶ /tdd-init ──────────────▶ [ CONSTITUTION.md & CONSTRAINTS.md ]
    ▼
[ Phase 0: ARCHITECTURE & DISCOVERY ]
    │   ├─▶ /tdd-map-architecture ──▶ [ docs/ARCHITECTURE.md (Test Seams) ]
    │   └─▶ /tdd-explore-ideas ─────▶ [ docs/discovery/ (5-Step Assessment) ]
    ▼
[ Phase 1: SPECIFICATION & PRD ]
    │   ├─▶ /tdd-prd ───────────────▶ [ docs/prd/ (BDD Given-When-Then) ]
    │   ├─▶ /tdd-clarify ───────────▶ [ Quality Gate: 40/30/30 Scoring ]
    │   └─▶ /tdd-spec ──────────────▶ [ /spec/ (Pre-Agreed Test Seams & ADR) ]
    ▼
[ Phase 2: QUALITY GATES & PLANNING ]
    │   ├─▶ /tdd-analyze ───────────▶ [ Blast Radius & Mocking Traps Audit ]
    │   ├─▶ /tdd-checklist ─────────▶ [ tasks/ (Test-Case Inventory Matrix) ]
    │   └─▶ /tdd-plan-tasks ────────▶ [ /plan/ (Tracer-Bullet Vertical Slices) ]
    ▼
[ Phase 3: TEST-FIRST EXECUTION ]
    │   ├─▶ /tdd-write-code ────────▶ [ Red-Green-Refactor + Floor-Guard ]
    │   └─▶ /tdd-pair-coach ────────▶ [ Socratic AI Pair Programming ]
    ▼
[ Phase 4: VERIFICATION & REMEDIATION ]
    │   ├─▶ /tdd-code-review ───────▶ [ 5-Axis Review: Spec, Health, Sec, Perf, Test ]
    │   └─▶ /tdd-bug-report ────────▶ [ Prove-It Pattern (Failing Test First) ]
    ▼
[ Phase 5: DOCUMENTATION & RETRO ]
    │   ├─▶ /tdd-generate-docs ─────▶ [ docs/ (Diátaxis Living Examples) ]
    │   └─▶ /tdd-retro ─────────────▶ [ Memory Sync & Test Speed Tuning ]
    ▼
[ ON-DEMAND UTILITIES ]
    ├── /tdd-ask-help ──────────────▶ [ Interactive SDLC Navigator & Guide ]
    ├── /tdd-configure-ci ──────────▶ [ CI Floor-Guard Pipeline Automation ]
    ├── /tdd-mutation-test ─────────▶ [ Mutation Testing & MSI Assertion Audit ]
    ├── /tdd-generate-fixtures ─────▶ [ Type-Safe Factories & Seeders ]
    └── /tdd-refactor-legacy ───────▶ [ Golden Master Characterization Tests ]
====================================================================================================

🚀 Quickstart via npx skills

Install the TDD-Spec bootstrapper directly into your project using the npx skills CLI:

# Using GitHub Shorthand (Recommended)
npx skills