<!-- SPDX-License-Identifier: MIT --> <!-- Copyright (c) PromptKit Contributors -->

PromptKit

<p align="center"> <img src="PromptKit-logo.png" alt="PromptKit logo — composable prompt toolkit" width="400"> </p> <p align="center"> <a href="https://aka.ms/PromptKit">aka.ms/PromptKit</a> · <a href="LICENSE">MIT License</a> </p>

Agentic prompts are the most important code you're not engineering. Every AI-assisted task — investigating bugs, writing requirements, reviewing code — lives or dies by the prompt that drives it. Yet most teams still write these prompts ad hoc: copy-pasted, untested, inconsistent, and impossible to improve systematically.

PromptKit treats prompts as engineered artifacts. It gives you composable, version-controlled components — personas, reasoning protocols, output formats, and task templates — that snap together into reliable, repeatable prompts. Three interactive workflows cover the full engineering lifecycle: bootstrap specifications from any codebase, evolve them under change with adversarial audits, and detect drift before it becomes debt. The same engineering rigor you apply to your software now applies to the prompts that build it.

A composable, versioned prompt library for engineering tasks — software, hardware, mechanical, RF, firmware, and protocol domains. Designed for engineers who design, build, verify, and ship.

157 components — 15 personas · 48 protocols · 21 formats · 5 taxonomies · 64 templates across 4 pipelines

The Engineering Lifecycle

PromptKit's three interactive workflows form a domain-agnostic engineering lifecycle — they work for software, hardware, mechanical, RF, protocol engineering, and beyond.

<!-- Alt-text: Diagram showing the engineering lifecycle as three stages in a cycle: Bootstrap (spec-extraction-workflow) feeds into Evolve (engineering-workflow) which feeds into Maintain (maintenance-workflow), and drift detected in Maintain loops back to Bootstrap. -->

 ┌──────────────────┐     ┌──────────────────┐     ┌──────────────────┐
 │    Bootstrap     │────>│     Evolve       │────>│    Maintain      │
 │                  │     │                  │     │                  │
 │  Scan repo,      │     │  Propagate       │     │  Detect drift,   │
 │  extract specs   │     │  changes with    │     │  correct specs   │
 │  (req / design   │     │  adversarial     │     │  and code        │
 │   / validation)  │     │  audits          │     │                  │
 └──────────────────┘     └──────────────────┘     └────────┬─────────┘
          ▲                                                 │
          └─────────────────────────────────────────────────┘
                           drift detected

| Stage | Workflow | What it does | Entry point | |-------|----------|--------------|-------------| | Bootstrap | spec-extraction-workflow | Scans any repository and extracts structured requirements, design, and validation specifications from existing code and artifacts | Read and execute templates/spec-extraction-workflow.md | | Evolve | engineering-workflow | Propagates a requirements change through specs and implementation with adversarial alignment audits at each stage | Read and execute templates/engineering-workflow.md | | Maintain | maintenance-workflow | Periodic drift detection — finds where code and specs have diverged, then corrects both | Read and execute templates/maintenance-workflow.md |

Each workflow is interactive (mode: interactive) — it runs directly in your LLM session, guiding you through structured phases with built-in challenge and verification steps.

Prerequisites

• Node.js 18+ — Install Node.js (required for npx @alan-jowett/promptkit)
• Git — Install Git (only needed if cloning the repo)

To use the interactive mode, you'll also need one of the following LLM CLI tools:

• GitHub Copilot CLI — Install the GitHub CLI, authenticate with gh auth login, ensure Copilot access is enabled for your account/organization, then run gh extension install github/gh-copilot
• Claude Code — Install Claude Code

Not using a CLI tool? See Using with any LLM (manual).

Quick Start

Using npx (recommended — no clone needed)

# Interactive mode — detects your LLM CLI and launches bootstrap
npx @alan-jowett/promptkit

# Browse the full component catalog
npx @alan-jowett/promptkit list --all

# Search for components by keyword
npx @alan-jowett/promptkit search "memory safety"

# Show details and cross-references for a component
npx @alan-jowett/promptkit show review-cpp-code

# List available templates (backward compatible)
npx @alan-jowett/promptkit list

📖 Full component catalog: See CATALOG.md for a browsable reference of all components with a cross-reference index — no CLI needed.

Using the repo directly

Clone the repo and start a session — Copilot discovers the /promptkit skill automatically:

git clone https://github.com/microsoft/promptkit.git
cd promptkit

# Start a session — the /promptkit skill activates automatically,
# reads the manifest, and asks what you need.
copilot

You can also invoke the skill explicitly with /promptkit, /boot, or /bootstrap.

What a session looks like

The bootstrap engine discovers all components via manifest.yaml and presents the available templates:

● Read bootstrap.md  (via /promptkit skill)
● Read manifest.yaml

I've loaded the PromptKit manifest. I'm ready to help you build a task-specific prompt.

Available templates (64):

┌────────────────────────┬───────┬──────────────────────────────────────────────────────┐
│ Category               │ Count │ Examples                                             │
├────────────────────────┼───────┼──────────────────────────────────────────────────────┤
│ Document Authoring     │   16  │ author-requirements-doc, interactive-design,         │
│                        │       │ audit-traceability, validate-budget, ...             │
├────────────────────────┼───────┼──────────────────────────────────────────────────────┤
│ Engineering Workflow   │    8  │ engineering-workflow, spec-extraction-workflow,       │
│                        │       │ maintenance-workflow, audit-spec-alignment, ...      │
├────────────────────────┼───────┼──────────────────────────────────────────────────────┤
│ Code Analysis          │   10  │ review-code, review-cpp-code, exhaustive-bug-hunt,  │
│                        │       │ review-schematic, review-enclosure, ...              │
├────────────────────────┼───────┼──────────────────────────────────────────────────────┤
│ DevOps                 │    7  │ author-pipeline, triage-issues, author-release, ...  │
├────────────────────────┼───────┼──────────────────────────────────────────────────────┤
│ Investigation          │    6  │ investigate-bug, investigate-security,               │
│                        │       │ find-and-fix-bugs, fix-compiler-warnings, ...        │
├────────────────────────┼───────┼──────────────────────────────────────────────────────┤
│ Standards              │    4  │ extract-rfc-requirements, author-rfc, ...            │
├────────────────────────┼───────┼──────────────────────────────────────────────────────┤
│ Protocol Engineering   │    3  │ evolve-protocol, analyze-protocol-conflicts, ...     │
├────────────────────────┼───────┼──────────────────────────────────────────────────────┤
│ Code Generation        │    3  │ author-implementation-prompt, author-test-prompt, ...|
├────────────────────────┼───────┼──────────────────────────────────────────────────────┤
│ Testing · Planning ·   │    7  │ discover-tests-for-changes, plan-implementation,     │
│ Agent · Contribution   │       │ author-agent-instructions, extend-library, ...       │
└────────────────────────┴───────┴──────────────────────────────────────────────────────┘

Personas: systems-engineer · electrical-engineer · rf-engineer ·
          mechanical-engineer · protocol-architect · ... (15 total)

What would you like to accomplish?

Describe your task and the LLM selects the right persona, protocols, and format, then assembles a complete prompt you can use in a fresh session.

See it in action: Examples — From One-Liner to Engineered Prompt shows what PromptKit actually assembles for tasks like C++ code review, compiler warning remediation, and adversarial bug hunting.

Using with Claude Code

Claude Code does not support CLI skills, so use the manual bootstrap command:

cd promptkit
claude "Read and execute bootstrap.md"

Using with any LLM (manual)

If your tool doesn't support skills or file access, paste the bootstrap prompt into a session along with the manifest, then follow the interactive flow:

1. Copy the contents of bootstrap.md into a new LLM chat.
2. Copy the contents of manifest.yaml into the same chat.
3. Describe your task.
4. The LLM will tell you which files to paste in (persona, protocols, etc.)
5. Paste the requested files, get the assembled prompt back.

CLI Reference

The promptkit CLI provides these commands:

| Command | Description | |---------|-------------| | promptkit | Launch interactive session with auto-detected LLM CLI | | promptkit list | List available templates (default) or all components | | promptkit search <keyword> | Search components by keyword across name + description | | promptkit show <name> | Show component details with cross-references |

promptkit list

promptkit list [options]

Options:
  --all                 Show all component types (not just templates)
  --type <type>         Filter by type (persona, protocol, format, taxonomy, template)
  --category <category> Filter by category (e.g., document-authoring, co