Propulsion

Propulsion is a set of composable Agent Skills for software delivery, from product definition and planning to implementation, review and maintenance.

Each skill has a narrow scope and a clear outcome. Lifecycle entry points bring supporting skills together, so you can ask for an outcome without managing every step yourself.

Planning works breadth-first. Establish the product's scope, explore a selected feature, then break it into small executable tickets. Start wherever you have enough context. A small, understood change can go straight to $implement.

Installation

Skills CLI

Install the full set with the Skills CLI, including the supporting skills used by lifecycle entry points:

bunx skills@latest add moonpixels/propulsion --skill '*'

Choose your coding agents when prompted. Add --global to make the skills available across projects.

Local symlinks

From the root of a local Propulsion clone, link the skills into the shared Agent Skills directory:

mkdir -p "$HOME/.agents/skills"
for skill_path in "$PWD"/skills/*; do
    ln -s "$skill_path" "$HOME/.agents/skills/"
done

Use this with clients that discover ~/.agents/skills. Edits in the clone are available through the links without reinstalling.

Lifecycle entry points

Choose the skill for the outcome you need. Each invocation finishes its own task. You decide when to move to the next one.

Skill	Start here to…
$define-product	Explore a new app idea or revisit an existing product. Establish its goals, journeys, shared requirements and feature index in PRODUCT.md.
$specify-feature	Define one feature's behaviour, acceptance examples and consequential technical choices. Produce a specification ready for ticket planning.
$create-tickets	Break requested work into small vertical slices. Create executable tickets with acceptance criteria and dependencies.
$implement	Deliver a ticket or another understood change. Produce a minimal local implementation with applicable checks, simplification and independent review.
$commit	Record all uncommitted branch changes in atomic Conventional Commits.
$pull-request	Publish the branch for review. Commit any remaining changes, push the branch, and create or update its pull request.
$review-pull-request	Independently assess an existing PR against engineering standards and available requirements. Return findings for you to act on.
$simplify-code	Aggressively simplify a feature, module or codebase while preserving behaviour. Produce verified changes and a durable running report.
$debug	Investigate a failure and establish its cause. Ask for diagnosis alone or a repair with implementation and verification.
$upgrade-dependencies	Update dependencies and build or CI tooling through checked migrations. Include language or runtime upgrades when requested.

Example workflow

Imagine building Shelf, a personal reading list app. The following prompts follow the same idea from planning to maintenance. Use each in a separate session when you are ready, replacing the illustrative document, ticket and PR references with your own.

Start with the whole app, then select its first feature:

$define-product Shelf, an app for saving books I want to read and tracking my progress

$specify-feature the reading list in @PRODUCT.md, including adding books and marking them as read

Turn the feature into tickets, then implement them in dependency order. For example, start with the ticket for adding a book:

$create-tickets for @docs/features/reading-list/specification.md

$implement @docs/features/reading-list/tickets/TKT-007-add-book.md

Record completed work when it forms a coherent unit. Publish the branch when it is ready for review:

$commit

$pull-request for Shelf's reading list feature

Review the resulting PR:

$review-pull-request #12 against @docs/features/reading-list/specification.md

As Shelf grows, use the maintenance entry points for specific needs:

$simplify-code Shelf's reading list feature

$debug and fix Shelf adding the same book twice when I submit the form once

$upgrade-dependencies in Shelf to the newest compatible stable versions

Supporting skills

Lifecycle entry points invoke these focused capabilities when needed. You can also call them directly.

Skill	Purpose
$elicit	Resolve material questions and decisions through a confirmed dialogue.
$elicit-with-context	Clarify a software task while maintaining project terminology and qualifying decision records.
$research	Produce a durable cited research report.
$select-packages	Delegate read-only discovery and return a succinct package recommendation.
$modular-design	Design simple interfaces that hide domain knowledge and complexity.
$test-design	Design minimal tests for observable behaviour.
$measure-code-complexity	Measure code complexity and interpret signals that warrant attention.
$code-cleanup	Independently identify deletions and simplifications that preserve behaviour.
$code-review	Independently assess code against requirements and engineering standards.
$maintain-agents	Keep project instructions in AGENTS.md concise and current.
$maintain-ubiquitous-language	Sharpen project terminology and maintain GLOSSARY.md.
$maintain-decision-records	Preserve significant technical rationale and decision history.
$write-prose	Write clear, succinct UK English.
$write-skill	Create or refactor concise skills and verify their behaviour.

Sources and acknowledgements

Propulsion draws on these skill collections and resources:

• obra/superpowers
• mattpocock/skills
• PStack
• Refactoring Guru