Skip to content
/
Tier B A8 Cross-runtime harness

PromptKit (ozzeron/prompt-pack)

ozzeron-prompt-pack-promptkit · ozzeron/prompt-pack · ★ 6 · last commit 2026-05-13

Primitive shape 23 total
Skills 23
00

Summary

ozzeron/prompt-pack (PromptKit) — Summary

prompt-pack is a curated, opinionated 23-skill discipline library for AI coding assistants that combats the most consistent failure mode of AI agents: creating new artifacts (components, hooks, utilities, types) when equivalent ones already exist in the codebase. Rather than offering a broad catalogue of role prompts, it ships exactly the skills needed to enforce DRY discipline, convention discovery, token budget awareness, and structured handoff — each skill earning its place through nine external review rounds and four empirical field tests on real codebases.

Problem it solves: AI coding agents operating without explicit reuse guidance routinely duplicate code, drift from project conventions, add unnecessary dependencies, and produce scope-creep — independent of model quality. Larger prompt catalogues amplify rather than fix this. prompt-pack enforces a strict reuse-before-create decision flow as a precondition for any code-creating action.

Distinctive trait: Every code-creating skill in the pack inherits meta/reuse-before-create and meta/engineering-principles through explicit ## Inherits frontmatter — forming a composable inheritance chain within skill files, so the DRY rule is automatically in scope before any new artifact can be written.

Installation model: A multi-target installer (bash + PowerShell) with six profiles and nine output targets — Cursor 2.4+ native skills, universal .agents/skills/, Claude Code subagents, Codex, OpenClaw, raw paste. A built-in lint-skills.mjs validates frontmatter format, section ordering, link integrity, and profile references on every PR.

Scope: 23 skills across architecture, review, delivery, interface, infra, and meta categories. Purposely small — competes with giant awesome-* lists by being audited and opinionated instead of exhaustive.

Differs from seeds: Closest to superpowers (skills-only behavioral framework, no commands or hooks) but differs architecturally — superpowers uses a SessionStart hook to inject a bootstrap skill; prompt-pack uses no hooks at all, relying entirely on native host skill discovery (descriptions as activation surface) plus a task-router for legacy/orchestrated flows. Unlike BMAD-METHOD's persona-per-role approach, prompt-pack uses skill-level ## Inherits chains that compose without persona switching.

01

Overview

ozzeron/prompt-pack — Overview

Origin

Published under the GitHub handle ozzeron as prompt-pack. 6 stars, 2 contributors as of 2026-05-26. Language: PowerShell (installer). License: unknown (not specified in repo). Active as of 2026-05-13.

Philosophy

The README states the core thesis directly:

"Under those prompts, agents ship the same recurring failures regardless of model: duplicate components, fresh utilities for things that already exist in the repo, dependencies added for problems the project already solved, convention drift, scope creep, and 'helpful' rewrites of code that was fine. Bigger catalogues do not fix this; they multiply the surface where it can happen."

And the opposing bet:

"prompt-pack picks the opposite trade-off: fewer skills, stronger behaviour. 23 curated skills, lint-gated, native skill discovery... the pack ran on real codebases and we patched what dropped, including the encoding and Cursor-format issues a model-only review would never have caught."

Manifesto-Style Quotes

"This is not a prompt directory. It is a small, opinionated discipline pack designed to reduce the technical debt AI coding agents generate by default."

"Bigger context is not smarter context. Tokens are an attention budget; spend them where they buy reliability."

"The discipline that does the work: 1. Reuse before create. A central reuse-before-create skill, inherited by every code-creating role, forces the agent to search for an existing artifact before adding a new one. Every 'new' entry needs a one-line justification."

"Each prompt earns its place. No 200 variants of 'you are a senior X'."

Design Decisions

  • 23 skills is treated as a feature, not a limitation — the whole catalogue is readable in one sitting
  • Skills have structured YAML frontmatter with triggers, applies_to, version, category
  • A built-in linter enforces format on every PR: required sections in strict order, description ≤ 120 chars, file length 80–310 lines, no project-specific leakage
  • Nine installer targets support every major AI coding tool without platform lock-in
  • Six profiles (minimal, nextjs, backend, supabase, fullstack, all) let teams pick a relevant subset
  • The pack was empirically tested on four real codebases, patching encoding and format issues a model-only review would miss
02

Architecture

ozzeron/prompt-pack — Architecture

Distribution

  • Type: Standalone repo — clone once, run installer per target project
  • License: Not specified
  • Language: PowerShell (installer) with bash companion

Install Methods

# Clone once
git clone https://github.com/Ozzeron/prompt-pack.git ~/code/prompt-pack

# Install into a project (bash)
cd ~/code/your-project
~/code/prompt-pack/install.sh --target cursor --profile minimal

# PowerShell
cd $HOME\code\your-project
& $HOME\code\prompt-pack\install.ps1 -Target cursor -Profile minimal

Directory Tree

prompt-pack/
├── prompts/
│   ├── architecture/
│   │   ├── backend-api/SKILL.md
│   │   ├── database-migrations/SKILL.md
│   │   ├── database-schema/SKILL.md
│   │   ├── frontend-feature/SKILL.md
│   │   ├── postgres-supabase/SKILL.md
│   │   └── refactor-planner/SKILL.md
│   ├── review/
│   │   ├── code-review/SKILL.md
│   │   ├── repo-audit/SKILL.md
│   │   ├── security-review/SKILL.md
│   │   ├── frontend-audit/SKILL.md
│   │   ├── database-review/SKILL.md
│   │   ├── duplication-audit/SKILL.md
│   │   └── debugger/SKILL.md
│   ├── interface/
│   │   └── ui-designer/SKILL.md
│   ├── delivery/
│   │   ├── handoff/SKILL.md
│   │   ├── test-writer/SKILL.md
│   │   ├── doc-writer/SKILL.md
│   │   └── ai-agent-docs/SKILL.md
│   ├── infra/
│   │   └── docker/SKILL.md
│   └── meta/
│       ├── task-router/SKILL.md
│       ├── engineering-principles/SKILL.md
│       ├── reuse-before-create/SKILL.md
│       └── token-discipline/SKILL.md
├── templates/
│   ├── codex-agents-md.md   # AGENTS.md bridge template
│   └── cursor-bridge.mdc    # cursor legacy bridge
├── scripts/
│   └── lint-skills.mjs      # CI skill linter
├── docs/
│   ├── USAGE.md
│   ├── CONTRIBUTING.md
│   └── PROMPT-FORMAT.md
├── install.sh
├── install.ps1
└── package.json

Required Runtime

  • Node.js (for lint-skills.mjs linter in CI)
  • bash or PowerShell (for installer)
  • No daemon, no server, no special runtime for the skills themselves

Target AI Tools

Nine output targets:

  • cursor — Cursor 2.4+ native Skills format (.cursor/skills/<name>/SKILL.md)
  • cursor-foundation — Foundation-only rules to .cursor/rules/*.mdc
  • cursor-rules — Legacy Cursor .cursor/rules/*.mdc format
  • agents — Universal .agents/skills/<name>/SKILL.md (Cursor 2.4+, Codex, GitHub Copilot)
  • claude-code — .claude/agents/ subagents
  • codex — .agents/skills/ + compact AGENTS.md router
  • codex-agents-md — Single concatenated AGENTS.md (legacy)
  • openclaw — <project>/skills/ for OpenClaw workspace
  • raw — Stripped SKILL bodies to docs/ai-rules/ for paste

Config Files

  • package.json (linter dep: yaml package)
  • No per-project config file
03

Components

ozzeron/prompt-pack — Components

Skills (23 total)

All skills are SKILL.md files with YAML frontmatter. Format: skill-md.

Meta Skills (4) — inherited by other skills

Name Purpose
meta/engineering-principles Cross-cutting standards: DRY, single-responsibility, type safety, file size limits, naming conventions
meta/reuse-before-create The core DRY precondition: strict ordering (reuse → extend → compose → extract → create new), mandatory one-line justification when creating
meta/token-discipline Attention budget rules: what to read first, what to skip, how to constrain search
meta/task-router Maps user intents to specific roles for legacy/orchestrated flows; includes composed flows (PR review = code-review → security-review)

Architecture Skills (6)

Name Purpose
architecture/backend-api Design backend API endpoints; inherits engineering-principles + reuse-before-create
architecture/frontend-feature Implement frontend features in React/Next.js conventions
architecture/database-schema Design database schemas
architecture/database-migrations Write migration files safely
architecture/postgres-supabase Postgres + Supabase RLS specific patterns
architecture/refactor-planner Plan refactors with scope limits and convention inspection

Review Skills (7)

Name Purpose
review/code-review Code review with structured findings
review/repo-audit Repository-level audit for conventions and patterns
review/security-review Security-focused review
review/frontend-audit Frontend-specific audit
review/database-review Database query and schema review
review/duplication-audit Find and report duplicate artifacts across codebase
review/debugger Systematic bug investigation

Delivery Skills (4)

Name Purpose
delivery/handoff End-of-task summary; part of minimal profile
delivery/test-writer Write tests for existing code
delivery/doc-writer Write documentation
delivery/ai-agent-docs Write documentation specifically for AI agent consumption

Interface Skills (1)

Name Purpose
interface/ui-designer UI component design with convention inspection

Infra Skills (1)

Name Purpose
infra/docker Dockerfile and compose configuration

Scripts

Name Purpose
scripts/lint-skills.mjs CI linter: validates frontmatter, section ordering, description length, link integrity, no project leakage, profile consistency

Templates

Name Purpose
templates/codex-agents-md.md AGENTS.md bridge template for Codex legacy targets
templates/cursor-bridge.mdc cursor .mdc bridge for legacy rules targets

Profiles (installer presets)

Profile Skill count
minimal 4
nextjs 10
backend 13
supabase 14
fullstack 21
all 23

No Commands, Hooks, or MCP Servers

The pack ships zero slash-commands, zero lifecycle hooks, and zero MCP servers. Activation is via native host skill discovery (trigger descriptions in frontmatter) or the task-router skill for orchestrated flows.

05

Prompts

ozzeron/prompt-pack — Prompt Excerpts

Excerpt 1: meta/reuse-before-create — Precondition Enforcement Pattern

---
name: reuse-before-create
description: DRY discipline core. Before creating anything new, find what already exists. Every coding skill inherits this.
category: meta
version: 0.1.0
triggers: ["writing code", "adding component", "adding util", "adding type", "creating file", "new helper", "new hook"]
applies_to: [openclaw, cursor, claude-code, generic]
---

# Reuse Before Create

...

## The rule

**Before writing anything new, search for what already exists. Reuse first; create last.**

The order of preference is strict and non-negotiable:

1. **Reuse as-is** — existing artifact fits, import and use
2. **Extend** — add a prop, option, generic, or branch to existing artifact
3. **Compose** — combine existing artifacts into a new shape without rewriting them
4. **Extract** — pull a shared core out of two near-duplicates; both use the new core
5. **Create new** — only when none of the above apply

## Justification is not optional

When you do create something new, **a one-line justification is mandatory**, not a
nice-to-have. It belongs in the commit message, the PR description, the handoff, or as
an inline comment near the new artifact.

> *"Created `formatDateTz`: no existing util handles ISO date with timezone offset; the
> project's `formatDate` strips the zone."*

Prompting technique: Precondition enforcement via strict ordering. The skill establishes a non-negotiable decision tree before any code-writing can begin. By requiring a named justification format, it forces the agent to externalize its reasoning rather than silently defaulting to "create new."

Excerpt 2: meta/engineering-principles — Cross-Cutting Inheritance Anchor

---
name: engineering-principles
description: Cross-cutting engineering standards every coding skill inherits. DRY, modular, type-safe, maintainable, modern.
category: meta
version: 0.1.0
triggers: [inherit-only]
applies_to: [openclaw, cursor, claude-code, generic]
---

## 2. File and function size

Code is read more than written. Optimise for the next reader.

| Unit | Soft limit | Hard limit |
|---|---|---|
| Function | 40 lines | 80 lines |
| React component | 150 lines | 250 lines |
| File | 250 lines | 400 lines |
| Class | 200 lines | 350 lines |

When you approach the soft limit, **split**. Hitting the hard limit without splitting is a
code smell to flag in review.

## 3. Single responsibility

A function, component, hook, or module does **one thing**. If you can't describe what it
does in a single sentence without "and", split it.

## 4. Type safety (when the language supports it)

- **No `any`** in TypeScript without an inline comment explaining why and what's safer
- **No untyped function signatures** — params and return are annotated
- **Validate at trust boundaries** — user input, API responses, file imports, env vars.

Prompting technique: Tabular constraint definition with explicit numeric limits and "hard vs soft" distinction. By quantifying limits (40/80 lines, 150/250 lines) rather than saying "keep functions short," the skill gives the agent a concrete criterion to evaluate against. The triggers: [inherit-only] frontmatter marks this as a dependency, never a direct-activation skill.

09

Uniqueness

ozzeron/prompt-pack — Uniqueness & Positioning

Differs From Seeds

The closest seed is superpowers (skills-only behavioral framework, zero commands, zero MCP). Both enforce engineering discipline through skill files without requiring user to type slash-commands. The key differences: (1) superpowers injects a SessionStart hook to bootstrap methodology into every session automatically; prompt-pack has zero hooks and relies on native host skill discovery via frontmatter triggers — meaning behavior fires only when the host routes a matching intent, not on every session start. (2) superpowers skills are "Iron Laws with pre-built rationalization tables" that broadly govern the session; prompt-pack skills are scoped discipline modules with explicit ## Inherits chains, ## Scope boundaries, and ## Token discipline sections — the skills compose rather than govern globally. (3) BMAD-METHOD is also relevant: it uses persona-md files where roles have full identities; prompt-pack uses skills with functional inheritance chains and no persona concept. (4) Unlike agent-os (markdown scaffold, no primitives), prompt-pack ships a real skill format with CI-enforced structure.

Positioning

Self-described competitor: "awesome-cursorrules, awesome-claude-code-subagents, awesome-copilot, awesome-agent-skills, etc." — the large community catalogues. Its counter-positioning is: fewer skills, stronger behaviour, audited in the field.

Observable Failure Modes

  • Skills installed to wrong target (e.g., subagent format in a host that expects rules) — mitigated by 9 explicit targets but still easy to mismatch
  • ## Inherits chains only work if the host actually loads the referenced skill; shallow hosts may ignore them
  • No session injection means discipline only fires when the agent routes to the skill — an agent that doesn't use skill discovery will bypass all enforcement
  • task-router is itself a prompt, not a runtime; in high-context sessions it may be skipped or misapplied
  • 23 skills is purposely small; teams with unusual stacks (mobile, data science, embedded) will find gaps

Cross-Tool Portability

High — nine output targets spanning every major AI coding tool in 2026.

04

Workflow

ozzeron/prompt-pack — Workflow

Installation Flow

Step Artifact
Clone repo to ~/code/prompt-pack Local copy of pack
Run install.sh --target <target> --profile <profile> Skills written to target-specific paths
Agent's host discovers skills via description triggers Skills become available in AI tool

Skill Activation Flow

  1. User or agent triggers a coding action (matches triggers in frontmatter)
  2. Host skill discovery selects the appropriate skill (or task-router maps intent to skill)
  3. Skill ## Inherits section pulls in meta skills (reuse-before-create, engineering-principles)
  4. Agent executes precondition steps (search for existing artifacts) before writing code
  5. Agent writes one-line justification if creating a new artifact
  6. Delivery skills (handoff) produce structured end-of-task summary

Phase-to-Artifact Map

Phase Artifact
Convention discovery Mental model of project patterns (no file)
Reuse search Justification comment or inline note
Implementation Modified/new code files
Handoff Structured session summary

Approval Gates

None — the pack has no explicit approval gates or user confirmation steps. Behavioral enforcement is baked into skill instructions (precondition checks and mandatory justification), not gated on user approval.

CI Lint Gate

The lint-skills.mjs script enforces format on every PR:

  • YAML frontmatter with required fields (name, description, category, version)
  • Description ≤ 120 chars
  • Skill name matches directory name (kebab-case)
  • File length 80–310 lines
  • Required sections in strict order for non-meta skills
  • All internal markdown links resolve
  • No project-specific leakage (no owner-specific domain names)
  • All profiles in installer reference existing skills
  • All task-router references point to existing skills
06

Memory Context

ozzeron/prompt-pack — Memory & Context

State Storage

None. The pack ships no persistent state mechanism — no session files, no project-level memory, no database.

Context Strategy

The pack takes an explicit "attention budget" approach to context rather than a "minimize tokens" approach:

"The goal is not lower token usage. The goal is better signal per token. Even on unlimited budget, a model that reads everything is a model that mixes patterns from unrelated code and hallucinates with confidence."

This is operationalized in meta/token-discipline: each skill specifies which files to read first, what to skip, and how to constrain searches to the relevant scope before widening.

Cross-Session Handoff

The delivery/handoff skill produces a structured end-of-task summary intended for human review and the next session. This is not machine-parseable state but a narrative handoff document.

Context Compaction

No compaction mechanism. The pack does not address context window management — that is delegated to the host AI tool.

Persistence

Session: none. Project: none. Global: none. The pack installs skills as files; no runtime state accumulates.

07

Orchestration

ozzeron/prompt-pack — Orchestration

Multi-Agent

No explicit multi-agent architecture. The pack does not spawn subagents or orchestrate parallel work.

When installed to claude-code target, skills go into .claude/agents/ which enables Claude Code to run them as subagents — but this is the host tool's capability, not prompt-pack's design.

Orchestration Pattern

None. Single-agent, sequential skill execution.

For orchestrated flows (e.g., PR review = code-review → security-review), the meta/task-router skill provides intent-to-skill mapping, but this is a routing table in a prompt, not a runtime orchestrator.

Isolation Mechanism

None. Skills run in-place in the agent's working session.

Execution Mode

One-shot: triggered per coding action by skill discovery or task-router dispatch. No daemon, no continuous loop.

Multi-Model

No. The pack is model-agnostic and ships no model routing configuration.

Consensus

None.

Prompt Chaining

Limited. The task-router maps intents to sequences (code-review → security-review), which is a form of sequential prompt chaining, but there is no mechanism for one stage's output to become the next stage's structured input.

08

Ui Cli Surface

ozzeron/prompt-pack — UI / CLI Surface

CLI Binary

No dedicated CLI binary. The installer is a bash script (install.sh) and PowerShell script (install.ps1), not a named binary with subcommands.

Install commands are invoked directly:

./install.sh --target cursor --profile minimal
./install.sh --target agents --profile all
./install.sh --target claude-code --skill meta/engineering-principles

Local UI

None.

IDE Integration

Skills are installed into IDE-native paths:

  • Cursor: .cursor/skills/<name>/SKILL.md or .cursor/rules/*.mdc
  • Claude Code: .claude/agents/<name>/SKILL.md
  • Codex: .agents/skills/<name>/SKILL.md

Observability

None beyond the CI linter output. No audit log, no dashboard, no metrics.

CI Integration

The lint-skills.mjs script is designed for CI (exit code 0 = clean, 1 = failures) and validates the skill library itself on every PR — not the user's project.

Related frameworks

same archetype · same primary tool · same memory type

claude-mem (thedotmack) ★ 78k
A8 Cross-runtime harness

Background worker service captures every tool call as an observation, AI-compresses sessions, and auto-injects relevant past…

pi (badlogic/earendil) ★ 55k
A8 Cross-runtime harness

A minimal, hackable, multi-provider terminal coding agent that adapts to your workflows via npm-installable TypeScript Extensions…

Agent Skills (Addy Osmani) ★ 46k
A8 Cross-runtime harness

Encodes senior-engineer software development lifecycle as 23 auto-routed skills and 7 slash commands for any AI coding agent.

wshobson/agents Plugin Marketplace ★ 36k
A8 Cross-runtime harness

Single Markdown source for 83 domain-specialized plugins that auto-generates idiomatic artifacts for five AI coding harnesses.

TabbyML/Tabby ★ 34k
A8 Cross-runtime harness

Self-hosted AI coding assistant server (alternative to GitHub Copilot) with admin dashboard, RAG-based completions, and multi-IDE…

Compound Engineering ★ 17k
A8 Cross-runtime harness

Make each unit of engineering work compound into easier future work via brainstorm→plan→execute→review→learn cycles.