pattern

Build tracked, runnable pattern codebases from recurring engineering lessons.

2|Updated Jul 11, 2026
One-click install
npx skills add https://github.com/nmnmcc/skills --skill pattern-nmnmcc
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: pattern
Source: https://github.com/nmnmcc/skills/tree/main/skills/pattern
Command: npx skills add https://github.com/nmnmcc/skills --skill pattern-nmnmcc

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

This Skill helps you capture a recurring engineering lesson as a standalone, runnable codebase so it can be taught, tested, and reused instead of remaining an informal rule or one-off example.

Core Features & Use Cases

  • Pattern Extraction: Distills a real relation into situation, tensions, response, consequences, and boundary.
  • Runnable Teaching Project: Organizes the lesson into a tracked patterns/<pattern-name>/ codebase with implementation, tests, fixtures, and learner-facing documentation.
  • Pattern Lifecycle Management: Supports creating, applying, revising, splitting, merging, and retiring patterns as evidence changes.
  • Use Case: A team notices a reliable way to structure recurring work and wants to turn it into a reproducible project that others can run and verify.

Quick Start

Use the pattern skill to turn a recurring engineering lesson into a tracked, standalone codebase under patterns/<pattern-name>/.

Frequently Asked Questions about pattern

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I turn recurring engineering lessons into runnable codebases?

You capture recurring engineering lessons by distilling them into situation, tensions, response, consequences, and boundary, then organizing them into a tracked patterns/<pattern-name>/ directory with implementation, tests, fixtures, and learner-facing documentation.

What is a runnable pattern codebase for software engineering?

A runnable pattern codebase is a standalone project under patterns/<pattern-name>/ that contains a reference implementation, guided experiment, verified commands, and learner-facing documentation to make engineering lessons transferable and reproducible.

How do I manage the lifecycle of engineering patterns as evidence changes?

Managing engineering pattern lifecycles involves creating, applying, revising, splitting, merging, and retiring patterns as evidence changes, ensuring existing pattern directories stay accurate and verified over time.

Can I use this to maintain an existing pattern directory with tests and fixtures?

Yes, you can maintain existing pattern directories by revising, splitting, merging, or retiring patterns as evidence changes, keeping the reference implementation, verified commands, and tests up to date.

What's the best way to document engineering patterns for team teaching?

The best way to document engineering patterns for teaching is to structure them as standalone codebases with learner-facing documentation, guided experiments, and verified commands that others can run and reproduce directly.

Do I need a separate codebase for each engineering pattern?

Yes, each engineering pattern requires a standalone patterns/<pattern-name>/ codebase containing its own reference implementation, tests, fixtures, and documentation to ensure it is independently runnable and verifiable.