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.

This repository provides three 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.

3. 📐 Pólya Heuristic Coder Package (polya-coder/ & polya-coder/AGENTS.md):

   • Hub & Spoke modular skills (/polya-explore, /polya-spec, /polya-clarify, /polya-plan, /polya-code, /polya-review, /polya-docs, /polya-fix, /polya-fast-track, /polya-map) and autonomous triage (/polya-router) merging George Pólya's 1945 mathematical heuristic framework (How to Solve It) with Uncle Bob's Clean Architecture, Clean Code, and SOLID principles.
   • Full lifecycle: Discovery (/polya-explore), Spec (/polya-spec), Clarification (/polya-clarify), Planning (/polya-plan), The Pause Rule Gate, Implementation (/polya-code), Review (/polya-review), Documentation (/polya-docs), First-Principles Bug Remediation (/polya-fix), Fast-Track Bypass (/polya-fast-track), and Architecture Topography (/polya-map).
   • Integrated with memory-manager for persistent context retention across sessions.

• 🔌 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.

• Overview
• Getting Started
  • Prerequisites
  • Installation
• Custom Agents (Standard SDLC)
• Skills
• Workflow & Methodology (Standard SDLC)
• TDD-Spec SDLC Package (Test-First & Spec Kit)
• Pólya Heuristic Coder Package (Mathematical Problem-Solving & Clean Architecture)
• Supplementary Skills
• BYOK Copilot Config
• Advanced Customization Guide
• Contributing
• Resources
• Support
• License

• 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

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

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):

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.

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.

Installs the mathematical problem-solving & Clean Architecture engineering suite (/polya-router & sub-skills):

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

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

Then in your AI Assistant chat window, run:

/polya-init setup this project

The bootstrapper agent will initialize project governance (AGENTS.md) and the SDLC rules. After initialization, you can invoke the Veteran Principal Engineer by running:

/polya-router

The Veteran Principal Engineer supports both explicit modular sub-skills (e.g., /polya-spec, /polya-plan, /polya-code) and natural free-form task briefs via /polya-router (e.g., /polya-router fix checkout race condition with redis). It autonomously inspects your codebase across Clean Architecture seams, renders a Pólya Triage Card, and auto-routes to the optimal phase while strictly enforcing The Pause Rule.

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

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 ./

   For Pólya Heuristic Coder Package (polya-coder/):

   # Standard Platforms: copy polya-coder/.agents/ directly
   cp -r awesome-copilot-id/polya-coder/.agents ./
   cp awesome-copilot-id/polya-coder/AGENTS.md ./
   
   # Claude Code: copy contents of polya-coder/.agents/ into .claude/
   mkdir -p .claude && cp -a awesome-copilot-id/polya-coder/.agents/. .claude/
   cp awesome-copilot-id/polya-coder/AGENTS.md ./
   
   # Cursor: copy contents of polya-coder/.agents/ into .cursor/
   mkdir -p .cursor && cp -a awesome-copilot-id/polya-coder/.agents/. .cursor/
   cp awesome-copilot-id/polya-coder/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.

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/).

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 provide agents with specialized capabilities, workflows, and prompts. They are located in the .agents/skills/ directory (or the platform-equivalent: .claude/skills/, .cursor/skills/).

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

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

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

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!

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.

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.

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.

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

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.

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

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.

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

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

[ 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)

📖 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 ]
====================================================================================================

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

# Using GitHub Shorthand (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 will initialize project governance (CONSTITUTION.md, CONSTRAINTS.md, AGENTS.md), auto-map existing codebases into docs/ARCHITECTURE.md, and configure all 21 TDD skills.

1. 🧭 Interactive SDLC Navigator (/tdd-ask-help):
   • Automatically inspects filesystem artifacts (CONSTITUTION.md, docs/prd/, /spec/, /plan/, test files) to diagnose your exact project phase.
   • Provides ready-to-use prompt templates for new features, bug remediations, legacy refactors, and pair coaching.
2. 🏛️ Living Architecture Map (docs/ARCHITECTURE.md):
   • Auto-mapped by /tdd-init or /tdd-map-architecture to record test seams, test runners, and framework realities.
3. 🛡️ Floor-Guard Anti-Cheat & Prove-It Discipline:
   • Rejects @ts-ignore, skipped tests, or tautological assertions.
   • Mandates failing automated regression tests before fixing any bug.
4. 🔒 3-Layer Anti-Injection Shield:
   • Enforces strict data boundary protocols across all 21 skills, treating all ingested test inputs, fixtures, and external payloads strictly as inert reference data.

📖 Full Documentation: For complete deep-dive documentation, heuristic dictionary, templates, and setup guide, visit polya-coder/README.md.

The Pólya Heuristic Coder Package is an elite, highly disciplined software engineering kit designed for AI coding agents and human developers. It merges the legendary mathematical problem-solving heuristics of George Pólya (How to Solve It, 1945) with the industry-defining Clean Architecture, Clean Code, and SOLID principles of Robert C. "Uncle Bob" Martin into a modern modular Hub & Spoke architecture routed via /polya-router or invoked directly via dedicated slash commands (/polya-explore, /polya-spec, /polya-plan, /polya-code, etc.).

====================================================================================================
               POLYA-CODER MODULAR PIPELINE: DISCOVERY ➔ SPEC ➔ PLAN ➔ CODE ➔ REVIEW
====================================================================================================

[ Phase 0: DISCOVERY & EXPLORATION ] (Pólya Phase 0: Getting Acquainted)
      │
      ▼
┌───────────────────────────────┐
│ /polya-explore                │ ──▶ [ docs/discovery/ ] ──▶ ( Topography Critique, Trade-Offs, Spikes )
└───────────────────────────────┘
      │
      ▼
[ Phase 1: SPECIFICATION ] (Pólya Phase 1: Understand the Problem)
      │
      ▼
┌───────────────────────────────┐
│ /polya-spec                   │ ──▶ [ docs/spec/ & docs/adr/ ] ──▶ ( Sanity Check & Equation Mapping )
└───────────────────────────────┘
      │
      ▼
┌───────────────────────────────┐
│ /polya-clarify                │ ──▶ [ docs/audit/ ] ──▶ ( Interrogate Assumptions, Grill-Me A/B, Readiness Score )
└───────────────────────────────┘
      │
      ▼
[ Phase 2: PLANNING ] (Pólya Phase 2: Devising a Plan)
      │
      ▼
┌───────────────────────────────┐
│ /polya-plan                   │ ──▶ [ docs/plan/ ] ──▶ ( Land & Expand / Tracer Bullets )
└───────────────────────────────┘
      │
      ▼
┌───────────────────────────────┐
│ /polya-clarify                │ ──▶ ( Optional Plan Interrogation & Stress-Test )
└───────────────────────────────┘
      │
      ▼
🛑 MANDATORY GATE: THE PAUSE RULE
(Halt execution! Await explicit user confirmation before writing functional code)
      │
      ▼ [Approved]
[ Phase 3: IMPLEMENTATION ] (Pólya Phase 3: Carrying Out the Plan)
      │
      ▼
┌───────────────────────────────┐
│ /polya-code                   │ ──▶ ( Clean Code, Respice Finem, Boy Scout Rule, Surgical Edits )
└───────────────────────────────┘
      │
      ▼
[ Phase 4: REVIEW & AUDIT ] (Pólya Phase 4: Looking Back)
      │
      ├───────────────────────────────┐
      │ (If Verified & Approved)      │ (If Defects / Invariant Violations Emerge)
      ▼                               ▼
┌───────────────────────────────┐   ┌───────────────────────────────┐
│ /polya-docs                   │   │ /polya-fix                    │ ──▶ ( First Principles, Trace Broken Seam )
└───────────────────────────────┘   └───────────────────────────────┘
      │ [docs/{tutorials,how-to,reference,explanation}/]
      ▼
[ Phase 6: TECHNICAL DOCUMENTATION ] (Pedagogical Transfer & Diátaxis Framework)

════════════════════════════════════════════════════════════════════════════
[ CENTRAL ROUTER ]              ──▶ /polya-router     (Autonomous phase router & diagnostic hub)
[ FAST-TRACK BYPASS ]           ──▶ /polya-fast-track (Routine, XS/S, One-Shot Fixes)
[ ARCHITECTURE TOPOGRAPHY ]     ──▶ /polya-map        (Traverse, Seams, docs/ARCHITECTURE.md)
[ PERSISTENT MEMORY ]           ──▶ /memory-manager   (Checkpoint to memory.instructions.md)
════════════════════════════════════════════════════════════════════════════

1. 🛑 The Mandatory Pause Rule:
   • Strict gate between planning and execution. The agent is strictly forbidden from writing production code until the user explicitly reviews and approves the vertical slice plan.
2. 🎯 Land & Expand Vertical Slices (Tracer Bullets):
   • Every plan is decomposed into vertical slices connecting DB to UI that are independently demoable and verifiable. Layer-by-layer horizontal slicing is prohibited.
3. 🩺 First-Principles Bug Remediation:
   • Rejects blind patching, guesswork, or feeding raw stack traces in loops. Systematically bisects the search space to isolate the broken seam, formulate a failing reproduction test, and apply a surgical root-cause fix.
4. 🧠 Pólya's Mathematical Heuristic Arsenal:
   • Incorporates over 20 mathematical principles from George Pólya's 1945 treatise: The Inventor's Paradox (p. 121), Subconscious Incubation (p. 197), Specialization & Limiting Cases ($0, \infty$), Test by Dimension, Round-Trip Symmetry, and Reductio ad Absurdum.
5. 🛡️ Context Hygiene & New Session Mandate:
   • Enforces single-persona session isolation. Whenever a phase finishes, the agent executes a structured 4-step handoff (Artifact verification, memory checkpoint offer, fresh session recommendation, and ready-to-copy handoff prompt) to prevent context bleeding and token degradation.

Previously categorized as standalone "Prompts" and "Instructions", these optional capabilities have now been consolidated into the supplementary-skill/ directory as custom skills. These skills provide additional guidelines, workflows, and prompts that you can manually include in your platform's skills directory (e.g., .agents/skills/) to enhance your agents.

These skills enforce coding standards and best practices:

These skills provide structured workflows for common development tasks:

A ready-to-use configuration template for enabling BYOK (Bring Your Own Key) on GitHub Copilot in Visual Studio Code. Use your own API keys from various providers (OpenRouter, DeepSeek, Opencode Zen, Opencode Go, Kilo Gateway, and others) to extend the list of available chat models.

See the full documentation and setup guide: byok-copilot-config/

You can implement customizations incrementally, starting with the simplest options and gradually adding more complexity as needed.

Create custom instructions for consistent results across all your chat interactions. Custom instructions let you define common guidelines or rules for tasks like generating code, performing code reviews, or generating commit messages.

File location: .agents/instructions/ (or the platform-equivalent: .claude/instructions/, .cursor/instructions/)

Format:

---
applyTo: "**/*.ts"
description: "TypeScript coding standards"
---

# Your instruction content here

- Use strict type checking
- Follow functional programming principles
- Always handle errors explicitly

Use custom instructions to:

• Specify coding practices, preferred technologies, or project requirements
• Provide guidelines about commit messages or PR descriptions
• Set rules for code reviews (security, performance, coding standards)

You can use AI assistants to help create custom instructions based on programming books or documentation:

1. Upload a programming book PDF (e.g., "Eloquent JavaScript", "Clean Code", "Design Patterns") to:

   • Gemini AI (supports PDF upload)
   • Claude AI (supports PDF upload)
   • ChatGPT (supports PDF upload with Plus/Pro subscription)

2. Use this prompt:

   Study this programming book PDF carefully and create a GitHub Copilot custom instruction file based on the principles, patterns, and best practices from the book. 
   
   The instruction should:
   - Follow the .instructions.md format with YAML frontmatter
   - Include key principles from the book
   - Provide specific coding guidelines
   - Be practical and actionable for daily development
   

3. Review and customize the generated instruction file to match your team's needs

4. Save the file to your platform's instructions directory (e.g., .agents/instructions/) with a descriptive name (e.g., eloquent-js-codestyle.instructions.md)

Custom agents are specialist assistants for specific roles or tasks. In our architecture, you define them as Skills that include a dynamic persona activation block.

File location: .agents/skills/<skill-name>/ (or the platform-equivalent: .claude/skills/, .cursor/skills/)

Format: Create a SKILL.md file inside the skill folder:

---
description: "Frontend Developer Specialist"
---

## 🎭 Dynamic Persona Activation

# Frontend Developer Agent

You are a frontend development specialist focusing on React and TypeScript...

Use custom agents to:

• Create a planning agent for implementation plans
• Define a research agent that can reach external resources
• Create specialized agents for specific domains (frontend, backend, database, etc.)

Connect external services and specialized tools through Model Context Protocol (MCP) to extend chat capabilities beyond code.

Use MCP and tools to:

• Connect database tools to query and analyze data
• Integrate with external APIs for real-time information

Switch between different AI models optimized for specific tasks using the model picker in chat.

Use different models for:

• Fast models for quick code suggestions and simple refactoring
• Capable models for complex architectural decisions or detailed reviews
• Specialized models for vision processing or other specific tasks

Contributions are welcome! Whether it's:

• Adding new agents for specific development scenarios
• Improving existing instructions
• Creating new prompt templates
• Fixing bugs or improving documentation

Please feel free to submit a Pull Request.

• GitHub Copilot Customization Overview - Official VS Code documentation for customizing GitHub Copilot
• GitHub Copilot Documentation
• VS Code GitHub Copilot Extension
• Awesome Copilot - A curated list of GitHub Copilot resources, extensions, and examples
• VS Code BYOK Documentation - Official guide for bringing your own language model keys
• BYOK Config Template - Pre-built chatLanguageModels.json template included in this repository
• AgentSkills - Guide and reference for creating agent skills

If you find this repository helpful, please consider giving it a star! It helps others discover these resources.

This project is open source and available under the MIT License.