Skills by mintuz

Development Skills

Reusable skills, agents and plugin bundles for software development and personal productivity. They work with Codex, Claude Code and OMP. All three harnesses load the same skill directories under src/. Each harness manages its own plugin discovery, tool access and installation.

To choose a skill for a task, go to When to use the main skills.

Install with Codex

Run these commands in your shell:

codex plugin marketplace add mintuz/skills
codex plugin add core@mintuz-skills
codex plugin add web@mintuz-skills
codex plugin add typescript@mintuz-skills
codex plugin add system-design@mintuz-skills
codex plugin add product-management@mintuz-skills
codex plugin add app@mintuz-skills
codex plugin add life@mintuz-skills
codex plugin add principle@mintuz-skills

To install only some bundles, remove the lines that you do not need. To see the available bundles, run codex plugin list --marketplace mintuz-skills --available.

To install from the ChatGPT desktop app:

1. Add the marketplace.
2. Restart the app.
3. Open the Plugins Directory and choose Mintuz Skills.
4. Install the bundles that you need.

Install with Claude Code

Run these commands in your shell:

claude plugin marketplace add mintuz/skills
claude plugin install core@mintuz-skills
claude plugin install web@mintuz-skills
claude plugin install typescript@mintuz-skills
claude plugin install system-design@mintuz-skills
claude plugin install product-management@mintuz-skills
claude plugin install app@mintuz-skills
claude plugin install life@mintuz-skills
claude plugin install principle@mintuz-skills

To install only some bundles, remove the lines that you do not need.

You can also install from a Claude Code session. Run each command on its own: /plugin marketplace add mintuz/skills, then /plugin install <bundle>@mintuz-skills for each bundle.

Install with OMP

Add the marketplace before you install a plugin, so that OMP resolves name@mintuz-skills as a catalogue entry. Install only the bundles that you need. Run these commands in your shell:

omp plugin marketplace add mintuz/skills
omp plugin discover mintuz-skills
omp plugin install core@mintuz-skills
omp plugin install web@mintuz-skills
omp plugin install typescript@mintuz-skills
omp plugin install system-design@mintuz-skills
omp plugin install product-management@mintuz-skills
omp plugin install app@mintuz-skills
omp plugin install life@mintuz-skills
omp plugin install principle@mintuz-skills

The default scope is user, which makes a plugin available across projects. To limit discovery to one Git project, run the install command inside that project and add --scope project. Project scope is not a security sandbox.

You can also install from an OMP session:

/marketplace add mintuz/skills
/marketplace discover mintuz-skills
/marketplace install --scope project core@mintuz-skills
/reload-plugins

If a session is already running, run /reload-plugins after installation. Restart OMP if a plugin adds executable tools, hooks or extension modules.

To update installed plugins, refresh the catalogue first, then upgrade each plugin:

omp plugin marketplace update mintuz-skills
omp plugin upgrade core@mintuz-skills

OMP uses this repository's explicit .omp-plugin/marketplace.json catalogue. Each plugin also includes .omp-plugin/plugin.json metadata that matches the Claude Code and Codex directory layout. See the OMP marketplace documentation.

Call a skill

Each harness calls a skill by name with a different syntax. The examples in this README use unqualified skill names. For a Claude Code plugin installation, add the bundle prefix.

Harness	Syntax	Example
Claude Code plugin	/plugin:name	/core:reducer
OMP	/skill:name	/skill:reducer
Codex	$name	$reducer

When to use the main skills

This section covers the entry points and the skills that I use every day. The Skills tables list every other skill. The example prompts come from real Claude Code and OMP sessions, with project names and links replaced by placeholders.

Pick a skill

Situation	Skill
A task needs a full workflow: review, bug fix, spec, implementation, design	adam-mode
An open "which approach?" question needs an experiment before the real build	adam-mode Prototype (spike) playbook
One artifact must reach a high, confirmed bar over several rounds	gauntlet-loop
One artifact can take several shapes, and you want them judged in one pass	arena
The look of a UI concept is open, and the variants must differ	creative-seed
Existing code or a system has more moving parts than its behaviour needs	reducer
New work must stay at the minimum that the requirement needs	yagni
You need to know what the code does now	how
You need to know why the code exists in its current form	why

adam-mode

adam-mode is the main entry point. It is manual-only, so call it by name. It matches the request to a playbook, loads the skills that the playbook needs, delegates to adam-agent and proves the result before it reports.

It continues without asking on reversible work, such as branches, commits, PRs and CI repair. It stops before a merge, the auto-merge label, a force-push, a data deletion or a message to a person, unless you asked for that action in the session.

Request	Playbook
"Review this PR"	Review
"Implement spec 013" or "Make the fixes that you recommended"	Implement
"I have received a bug report"	Bug fix
"How does…", "Why does…", "Explain…" or "Are you sure?"	Investigate
"Redesign this from first principles with fewer moving parts"	Rethink
"Make this faster"	Perf
"Continue, my device crashed"	Resume
"Spike this" or "Prototype this"	Prototype
"The disk is full" or "Remove old worktrees"	Disk
"Make this match the mock-up"	Match design
"Write a spec" or "Create visual Given/When/Thens for this spec"	Spec
"Make this screen world class"	Design loop
"Make CI go green"	Ship

/adam-mode Review this PR: <PR URL>. Restate what we are trying to achieve, then consider the solution from first principles. Optimise for simplicity and reduced complexity.
/adam-mode I have received a bug report. Validate that it is a real issue, diagnose it and suggest a fix. [screenshot]
/adam-mode Create visual Given/When/Thens for this spec: <PR URL>
/adam-mode Start the implementation of spec 013. Optimise for simplicity and reduced complexity.
/adam-mode Make CI go green and add the auto-merge label.

Prototype (spike)

Prototype is a playbook in adam-mode, not a separate skill. "Spike" and "prototype" start the same playbook. Use it when a library choice, a layout, a feature, a product or a bug fix has more than one possible approach, and an experiment can settle the choice. The output is a decision and its evidence. The prototype code is throwaway and never ships.

• One open decision gets labelled variants behind one switcher, inside the running app.
• Several open questions get whole versions. arena builds and judges them, and short gauntlet-loop rounds improve the chosen base. The result is a keep list for the real build.

Do not use it when the spec already fixes the approach. For a bug, confirm the root cause first: a prototype compares fixes, not causes.

/adam-mode Spike a solution for this and give me code examples. It must work with our existing auto-layout algorithm.
/adam-mode I have a prototype in main. Build another prototype on top of it as a Tauri app.
/adam-mode Continue the spec generation. Consider the architecture, spike the hard parts and put the implementation details in the spec.

gauntlet-loop

Use gauntlet-loop when one artifact must reach a high bar and you expect several rounds: a screen, a flow, a visual language, a document or a system check. Separate builders make each round. A fresh critic gives each round a verdict of WIN, LOSE or UNJUDGEABLE against the bar.

The skill asks you to confirm the bar before round 1. Give it something that a critic can inspect: a screenshot, a production URL, a reference app, Mobbin screens or a checkable condition. "World class" alone is not a bar; the skill turns it into concrete criteria for you to confirm.

Do not use it for routine changes that have clear acceptance tests, or to choose between different shapes in one pass (use arena).

/gauntlet-loop Redesign the History view. It must be glanceable and show what a user wants to know about past sessions. Use Mobbin for inspiration.
The spacing, line height and padding of the Insights tab need polish. The screenshot shows where it is cluttered. Use /gauntlet-loop and Mobbin.
The site layout looks broken compared to production at <URL>. Use /gauntlet-loop with production and Mobbin as references to redesign it.
Do the previous task with /gauntlet-loop. The WIN is when every contradiction is removed or updated.

arena

Use arena when a non-trivial artifact can take several shapes, and a single first attempt would lock in one shape: an interface, a module design, a prompt, a document or a visual direction. It produces two or more independent candidates, judges them against one rubric, picks a base and grafts the best parts of the others into it. architect, the Prototype playbook and the Design loop playbook all use arena.

Do not use it for a task with one obvious answer, or to raise one artifact to a bar over several rounds (use gauntlet-loop).

Use /arena to draft three shapes of the CSV import API. Judge them on caller simplicity, error handling and testability, then graft the best parts into one.
Use /arena with three candidates for the onboarding copy. Rubric: plain UK English, under 40 words, no jargon.
/architect the sync module before we build it.

arena and gauntlet-loop answer different questions. Use arena first when the direction is open, then gauntlet-loop to raise the chosen direction to the bar.

	arena	gauntlet-loop
Question	Which shape is best?	Is this shape good enough yet?
Passes	One	Repeated rounds, until the evidence supports a stop
Input	The task, shared paths and a rubric	One artifact and a bar that you confirm
Output	One synthesised artifact and a synthesis note	One artifact, with a verdict for each round

creative-seed

Use creative-seed when you ask for UI concepts, prototype designs or exploratory visual variants whose look is open. Each variant gets a label, for example settings-concept/B. A script turns the label into a long string of letters and digits. The agent reads patterns in the string and derives the colour scheme, layout and typography from them. The design never shows the string. The same label always gives the same string, so you can regenerate a direction later.

Do not use it to match an agreed mock-up, or in repair rounds on a design that you already picked. Those rounds keep the pinned direction.

Build three concepts for the settings screen. Use /creative-seed to set the direction of each concept.
I like concept B, but not its colours. Reroll concept B with /creative-seed.

A reroll keeps the label and adds a number, for example settings-concept/B/2.

reducer

Use reducer when an existing system, feature or PR has more moving parts than its behaviour needs: branches, state, dependencies, layers or hand-written scripts. It records every supported behaviour in a behaviour ledger, derives the minimum mechanism from first principles and proves that the behaviour does not change. It can diagnose only (a design with no edits) or implement the change in reversible slices.

Do not use it to remove features. Removing a supported behaviour is a scope change that needs an owner decision.

Use /reducer on the changes that we have made.
This repo provisions my machines with make, Ansible, shell scripts and Homebrew. Go back to first principles. How can I reduce the number of moving parts?
/speckit-plan Use /reducer to find code and patterns that we can reuse instead of building new ones.

yagni

Use yagni when you change production code, especially when you implement a spec or a user story. Before it executes, it states a minimal plan: the goal, the non-goals, the acceptance criteria and what stays untouched. It writes the failing test first. It asks for a missing requirement and does not guess it.

Do not use it to remove complexity from existing code (use reducer). yagni stops new complexity; reducer removes complexity that is already there. Load both for most implementation and review work.

Implement spec 002 on a new branch against ios27. Use speckit, /yagni, /swiftui-architecture and /app-intent-driven-development.
Review the architecture of the changes that we have made. Use /yagni and /reducer. Look for ways to reduce and flatten complexity and deepen modules. More code is not always better.

how and why

Use how to explain what the code does now: the execution path and the owner of each piece of state. Use why to recover the reason that the code exists in its current form. why labels each finding as fact, inference or unknown. Both skills are read-only.

/how does XState connect to the new CanvasSurface?
/how What is the live-channel feature and how does it work? Give code examples with /pseudocode and sequence diagrams.
/why does this custom Python and shell code exist? I want to know if we can remove it and use a framework or tool instead.
/why did we remove that rule? Was a test deleted?

Combined examples

Review, fix and ship a PR. adam-mode runs the Review, Implement and Ship playbooks in order. Review and Implement use yagni and reducer; Ship uses commit-messages and babysit.

/adam-mode Do a deep review of <PR URL>. Look for ways to reduce and flatten complexity. Look for scope creep, features built outside the spec and features deleted without approval. Use /yagni, /reducer, /react, /xstate and /tailwind.
/adam-mode Make the fixes that you recommended.
/adam-mode Make CI go green and add the auto-merge label.

Implement a spec with one sub-agent for each user story. yagni keeps each story to its minimum and reducer keeps the integrated result flat.

/goal Implement spec 540 on a new branch as a single PR. Act as coordinator: spawn one sub-agent for each user story and integrate its work. Use /yagni, /reducer, /react, /xstate and /tailwind. After the last story, review the full implementation.

Redesign a screen. adam-mode runs the Design loop playbook. Round 1 runs through arena, and creative-seed sets the direction of each variant. From round 2, gauntlet-loop improves only the chosen base until a fresh critic gives a WIN.

flowchart LR
  A[Confirm the bar<br/>and references] --> B[arena: 2-3 variants<br/>each from creative-seed]
  B --> C[Judge picks a base<br/>and grafts the best parts]
  C --> D[gauntlet-loop rounds<br/>on the base only]
  D -->|LOSE| D
  D -->|WIN| E[Hand over or ship]

/adam-mode The site layout looks broken compared to production at <URL>. Use /gauntlet-loop with production and Mobbin as references to redesign it.

Spike a new platform feature. adam-mode runs the Prototype playbook. arena builds the variants, creative-seed sets their look, and gauntlet-loop improves the base. The output is a decision document, not shippable code.

/adam-mode The iPhone Duo is coming out. Read the documentation on how to support it, spike the solution, and use /gauntlet-loop with Mobbin to build different UI variants. Write a document of what we should change, with screenshots of the variants.

Understand, then simplify. Use how for the current behaviour, why for the reason behind it and reducer for the smaller design. Add blast-radius to see what a change can break.

/how What does the new useEffect in <file> do?
/why does it exist, and what are the alternatives? Use /blast-radius for each alternative.
/reducer Can we remove it without a change in behaviour?

Verification workflow

Keep requirements, executable checks and runtime evidence distinct:

• Use create-verification-skill once to record a project's launch, doctor, drive, evidence and cleanup procedures. Use maintain-verification-skill to keep that bundle and its host discovery entries accurate.
• Use tdd with the relevant authoring skill: frontend-testing, react-testing, browser-testing, swift-testing or xcuitest.
• Use the generated verify-<project> recipe to run existing checks and exercise real user journeys. Link existing BDD scenarios and test cases instead of copying their expectations into another specification.
• Use visual-feedback for interactive visual comparison, acceptance-review for requirement satisfaction, and double-check for a separate reviewer. None of them replaces machine-checked assertions.

Use existing runners and structured reports for repeatable assertions. Record the required checks before execution, keep failed attempts, and report blocked or unrun checks as gaps. A passing browser or simulator journey does not prove physical-device, accessibility or security coverage. Non-UI XCTest authoring still uses the project's existing XCTest conventions; do not force a migration to Swift Testing.

iOS skill owners

For iOS work, keep these owners separate:

Skill	Owns	Hands off
debug	Root-cause investigation of build/runtime identity, state, storage, lifecycle or crash faults	Rendering-only defects and agreed visual iteration to visual-feedback; execution to xcode-dev-loop
xcode-dev-loop	Toolchain, build/install/run/capture mechanics and native result inspection	Test authorship and visual judgement
xcuitest	UI-test actions, fixtures, waits and assertions	Exact cases, preconditions and proof requirements to the execution owner; unexplained behavioural failures with all attempt evidence to debug
visual-feedback	Actual image inspection, visual diagnosis and equivalent before/after review in web or iOS	Apple execution to xcode-dev-loop; broader iOS build/runtime identity, state, storage, lifecycle or crash faults to debug

Keep one execution owner at a time. Request controlled experiments through that owner; do not start a parallel simulator driver. Keep brief safety and evidence rules in each skill. If an optional companion skill is absent, use the project's documented commands. Core visual feedback keeps a standalone capture fallback.

Project verification bundles

Each project has one canonical recipe bundle, not three authored versions. Follow the project's convention. If the project has no convention, use .agents/skills with a Claude project-directory link, and add an OMP native link only when needed. Maintain every declared discovery entry. Prove loading and representative cold replay separately in each claimed host and target platform.

The verification evidence record separates treatment gates, advisory comparisons, activation checks and native runtime proof. It records the blocked native Claude replay and the limits of each web and iOS fixture. Filesystem parity alone is not host runtime proof.

Plugins

Plugin	Description
core	Core workflows: commits, learning, code review, prompts, PRs, writing, and persistent memory
web	Web development with CSS, React, Tailwind, TDD, testing, and design patterns
typescript	TypeScript strict mode, schema-first development, and best practices
system-design	Architecture visualisation with Mermaid diagrams
product-management	PRDs, task management with Task Master MCP, decision tracing, and status updates
app	Swift iOS development with App Intents, Swift Testing, and SwiftUI architecture
principle	Independent engineering principles, each invoked for a specific decision
life	Personal life management with the GPS method for goal achievement

Skills

Core

Skill	Description
acceptance-review	Verify implementation against an authoritative contract with an explicit verdict
babysit	Push a committed branch, open its PR, fix red CI and conflicts, and watch it through merge on GitHub, Forgejo or Gitea
commit-messages	Conventional commit messages that explain the "why" not just the "what"
yagni	Minimum sufficient execution, scope boundaries, TDD, and documentation practices
gauntlet-loop	Improve ambitious artifacts against a concrete bar using separate builders and fresh critics
graph-engineering	Orchestrate interdependent specs and stories as a contract-first execution graph with a verifier per node
record-lesson	Record a verified project lesson as the smallest rule in AGENTS.md or CLAUDE.md
pr	PR descriptions, sizing, and creation with gh CLI
pseudocode	Render module boundaries, signatures, arguments, and a cited call graph for existing or planned code
reducer	First-principles system simplification with behavioural equivalence proofs
writing-for-agents	Concise agent handovers and skill instructions that preserve scope, evidence and completion conditions
writing-for-humans	Draft, edit and review human prose with contextual word bans, medium-specific voice and factual safeguards
wtf	Re-explain an unclear response in plain, precise UK English
create-verification-skill	Create and cold-replay a shared project verification bundle with indexed coverage
maintain-verification-skill	Repair verification recipes and harness discovery without changing product expectations
visual-feedback	Reproduce and compare visual states in web and iOS applications
tdd	Framework-neutral Red-Green-Refactor workflow with explicit evidence
blast-radius	Trace material change risks and decisive checks
double-check	Second opinion from a fresh reviewer, ideally on another provider; findings close only on evidence
lens-review	Review a diff through installed skills as isolated lenses, verify every finding and return one ranked report
how	Explain the current execution path and state ownership
why	Recover rationale while separating fact, inference and unknown
benchmark-checklist	Check measurement correctness, repeatability and interpretation
correct	Turn recurring enforceable mistakes into verified structural guards
recall	Recover bounded past context and reconcile it with current evidence
adam-mode	Manual-only. Route a task to Adam's playbooks, principles and skills, and delegate through adam-agent
teach	Manual-only. Tutor you to mastery of a topic with Socratic questions, a 0–5 skill map, spaced review and a final assessment
architect	Sketch types, signatures and modules through arena, then implement against the agreed sketch
arena	Run independent attempts at one task, judge them on a rubric, pick a base and graft the best parts
sharpen	Manual-only. Make a task deeper, not bigger, then rewrite the prompt
in-your-own-words	Manual-only. Restate the user's goals and the problem they are trying to solve
creative-seed	Derive each UI concept's creative direction from a deterministic seed string that the design never shows

writing-for-agents covers cross-agent messages, agent instructions, and the creation or update of skills. It removes repeated instructions and filler without dropping operational constraints.

writing-for-humans covers articles, documentation, messages, marketing and UI text. It also improves the prose in PRs and commits without replacing their format rules. It drafts from sufficient source material, keeps useful voice, and applies default word bans with exceptions for accurate terms, quotations, code and names. It repeats its editorial checks until they pass; a justified exception counts as a pass.

The writing-for-humans behavioural suite compares the skill against no skill. Its activation suite checks discovery, specialist format owners and the adam-mode investigation caller.

Web

Skill	Description
css	CSS best practices for maintainable, scalable styles
react	Production-ready React architecture and patterns
xstate	Typed XState actor lifecycles with legal Mermaid statechart visualisation
react-testing	React Testing Library patterns for components, hooks, and context
frontend-testing	DOM Testing Library patterns for behaviour-driven UI testing
refactoring	Refactoring assessment and patterns after tests pass
web-design	Visual hierarchy, spacing, typography, and UI polish
tailwind	Design systems with Tailwind CSS, design tokens, and component libraries
browser-testing	Author real-browser tests and controlled screenshot comparisons with the project's runner
chatgpt-app-sdk	Build ChatGPT apps using OpenAI Apps SDK and MCP with conversational UX

App

Skill	Description
swift-testing	Swift Testing framework: @Test macros, #expect/#require patterns
xcuitest	Author XCTest UI automation with controlled fixtures, public interactions and lifecycle proof
app-intent-driven-development	Build features as App Intents first for Siri, Shortcuts, widgets, and SwiftUI
swiftui-architecture	Modern SwiftUI patterns: @Observable, state management, no ViewModels
debug	Structured feedback loop for debugging iOS simulator issues and UI problems
local-ai-models	On-device AI with Foundation Models and MLX Swift: LLMs, VLMs, embeddings, and image generation
app-store-scraper	Scrape iOS/macOS App Store data using iTunes/App Store APIs
app-store-keyword-ops	Mine Astro competitor keywords and safely update locale-specific App Store fields
ios-localize-copy	Localise iOS and App Store copy across every supported locale
xcode-dev-loop	Canonical xcodebuild build/test/simulator loop: background runs, result reading, screenshots
asc-screenshots	Upload App Store screenshots and previews through helm-asc: staging, locales, verification

TypeScript

Skill	Description
typescript	Schema-first development, strict typing, functional patterns, and Zod

Life

Skill	Description
gps-method	Evidence-based goal achievement framework using Goal, Plan, and System methodology

System design

Skill	Description
mermaid-generator	Generate Mermaid diagrams from code to visualise architecture and relationships

Product management

Skill	Description
decision-trace	Trace claimed decisions from source evidence through delivery artifacts
meeting-to-action-brief	Turn meeting evidence into a concise decision and action brief
status-updates	Team updates and stakeholder comms with scannable structure and honest tone
story-pr-orchestrator	Coordinate dependency-gated stories through isolated pull requests
design-handover	Explicitly transfer accepted behaviour, matching visuals, authority and durable assets

Principles

Each principle is an independent skill under src/principle/skills/, with its full principle-* name. Invoke the one that is relevant to the decision. No router or global principle mode is required.

Skill	Focus
principle-attack-the-premise	Challenge assumptions shared by failed approaches.
principle-build-the-lever	Automate repeated work when reuse earns it.
principle-capture-the-baseline	Record the before state before changing it.
principle-clean-up-what-you-started	Release only owned resources; keep the evidence.
principle-define-done	Give every deliverable a checkable completion criterion.
principle-derive-from-one-owner	One owner per fact; derive the rest.
principle-earn-every-element	Justify each control or option by a user need.
principle-encode-lessons-in-structure	Turn verified lessons into structural constraints.
principle-exhaust-the-design-space	Compare alternatives for material uncertainty.
principle-experience-first	Start from the observed user journey.
principle-explain-the-number	Report numbers with method and class-matched evidence.
principle-fix-root-causes	Repair the mechanism; rerun the original failure.
principle-fix-the-bar-first	Fix selection criteria before evaluating candidates.
principle-foundational-thinking	Build a foundation only when current work needs it.
principle-gaps-are-not-passes	Report skipped or failed checks as gaps.
principle-guard-the-context-window	Read in bounded slices; search before loading.
principle-hide-representations	Expose domain concepts, not wire or storage shapes.
principle-investigate-read-only	An investigation changes nothing it studies.
principle-judge-with-fresh-eyes	Builders never give the acceptance verdict.
principle-keep-secrets-out	Keep credentials out of output and repositories.
principle-keep-the-core-pure	Pure domain decisions; thin framework wiring.
principle-label-the-evidence	Mark each claim's status, evidence level and source.
principle-lead-with-the-answer	Put the answer first, background after.
principle-make-operations-idempotent	Handle retries, interruptions and owned cleanup.
principle-migrate-callers-then-delete-legacy-apis	Prove consumer coverage before deleting APIs.
principle-minimize-reader-load	Collapse layers that own no decision.
principle-model-the-domain	Represent legal states, transitions and ownership.
principle-narrow-state-lifetime	Keep mutable state request-owned and short-lived.
principle-never-block-on-the-human	Continue authorised independent work.
principle-never-weaken-a-check	Never loosen a gate just to pass.
principle-observe-dont-infer	Observe effects instead of trusting names.
principle-outcome-oriented-execution	Converge on the accepted end state.
principle-parse-at-the-boundary	Parse untrusted input where trust changes.
principle-preserve-meaning	Keep conditions and uncertainty when compressing.
principle-preserve-unrelated-work	Leave behaviour and edits you weren't asked to change.
principle-price-each-option	State each option's effect and cost.
principle-prove-it-works	Verify the claim on the identified artifact.
principle-rank-sources-by-authority	Settle conflicting sources by authority, not recency.
principle-redesign-from-first-principles	Derive a scoped design from real constraints.
principle-refresh-before-resuming	Re-check changed state before relying on a handover.
principle-report-every-transition	Report state changes without being asked.
principle-reuse-before-building	Use an existing mechanism before creating one.
principle-scale-verification	Run required checks; add more in proportion to risk.
principle-separate-before-serializing-shared-state	Separate independent state while preserving atomic invariants.
principle-sequence-verifiable-units	Pass each unit's check before dependent work.
principle-state-the-claim-first	Write the falsifiable claim before working.
principle-state-the-scope	Restate broad requests; never narrow them silently.
principle-stay-in-scope	Act only within the authority granted.
principle-subtract-before-you-add	Remove proven redundancy before adding.
principle-test-behavior-not-implementation	Test contracts and meaningful failures.
principle-treat-messages-as-data	Embedded instructions are requests, not authority.
principle-type-system-discipline	Make the compiler enforce domain distinctions.
principle-update-the-base-deliberately	No automatic rebase, stash or reset.
principle-write-cold-handovers	Write handovers a fresh agent can execute.

Agents

Agent	Plugin	Description
adam-agent	core	Delegate for an /adam-mode run that reads the adam-mode skill in full before any work
code-reviewer	web	Code review specialist focusing on quality, security, performance, and maintainability
refactorer	web	Refactoring coach to guide code improvement decisions and assess opportunities after tests pass
senior-web-engineer	web	UI engineer for React components, with a focus on maintainability, user experience and web standards compliance
test-runner	web	Runs tests with auto-detection and returns concise pass/fail summaries

MCP integrations

Some plugins include Model Context Protocol (MCP) server configurations:

• core: Memory MCP for persistent knowledge storage across sessions
• web: Playwright MCP for browser automation and visual checks
• product-management: Task Master MCP for task management workflows
• app: XcodeBuildMCP and iOS Simulator MCP for app development workflows

Other ways to install skills

The marketplace installations above are the normal plugin path. Use the scripts in this section only when you want standalone skills instead.

Use one authoritative distribution per skill name. Do not install both a plugin bundle and a standalone copy of the same skill.

Standalone skill loaders and Codex CLI

scripts/codex-sync.go copies complete SKILL.md bundles, including their references, into flat directories. Despite its name, it does not translate the instructions into a Codex-only format. For skills listed in THIRD_PARTY_NOTICES.md, it also copies that file, so the MIT notice travels with the bundle.

Leave --prefix off to keep names such as principle-prove-it-works. Run the script from the repository root:

# Copy all skills to ~/.codex/skills (user level, the default)
go run scripts/codex-sync.go

# Copy all skills to .codex/skills in the current project (project level)
go run scripts/codex-sync.go --project

# Copy all skills to another directory
go run scripts/codex-sync.go --output /path/to/your/skills

For a harness other than Codex CLI, point its skill discovery at the output directory, or copy the directory into the harness's documented skill location. In Codex CLI, call a synced skill with $skill-name, for example $commit-messages or $react.

See scripts/README.md for more options, including skill name prefixes and dry-run mode.

Claude web

The .dist folder contains one zip file for each skill, ready to upload to Claude web (claude.ai). You can upload each zip file independently.

1. To regenerate the zip files, run the packaging script from the repository root:

   go run scripts/package-skills.go
   

   The script creates files such as .dist/commit-messages.zip, .dist/react.zip and .dist/swift-testing.zip.

2. Go to claude.ai.

3. Open the skills section.

4. Upload the zip files that you need from .dist.

The uploaded skills are then available in your Claude web conversations. See scripts/README.md for more options, including custom output directories and skill name prefixes.

Plugin metadata and validation

A marketplace catalogue lives at the repository root. Each plugin has a manifest inside its own src/<plugin>/ directory, not another marketplace.

Harness	Root catalogue	Per-plugin manifest
Codex	.agents/plugins/marketplace.json	.codex-plugin/plugin.json
Claude Code	.claude-plugin/marketplace.json	.claude-plugin/plugin.json
OMP	.omp-plugin/marketplace.json	.omp-plugin/plugin.json

Keep the OMP catalogue and manifests identical to their Claude Code copies. OMP prefers its own catalogue over the Claude Code fallback. Its runtime discovers the conventional component directories and uses the compatible Claude Code metadata where needed, so keep both sets of manifests.

After you change a plugin:

1. Set the same version in all three of its manifests.

2. Set that version on its Claude Code and OMP catalogue entries, so that OMP can detect available upgrades.

3. Keep the plugin names and source paths aligned in all three catalogues.

4. Run the repository metadata check. It makes no model calls and does not change host configuration:

   pnpm check:plugins
   

The check covers plugin and skill inventories, source paths, repository URLs, versions and MCP configuration paths. It does not execute skills or start MCP servers. Before you publish, also validate and install through the target harness.