atomic-run

Execute plans atom by atom with molecule-based grouping and summaries.

Updated Apr 14, 2026
One-click install
npx skills add https://github.com/ysgdepaula/x-deep-os --skill atomic-run
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: atomic-run
Source: https://github.com/ysgdepaula/x-deep-os/tree/main/.claude/skills/atomic-run
Command: npx skills add https://github.com/ysgdepaula/x-deep-os --skill atomic-run

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Allows teams to implement a plan step-by-step, atom by atom, while grouping steps into review-friendly molecules to minimize cognitive load and improve traceability.

Core Features & Use Cases

  • Molecule-based execution: run atoms in predefined molecule batches to balance speed and reviewability.
  • Plan parsing and weighting: automatically categorize tasks by cognitive weight (mechanical, light, cognitive) and form molecules accordingly.
  • Commit-style reporting: after each molecule, provide a concise summary for review and approvals, then proceed automatically.
  • Use Case: Imagine you have a multi-step implementation plan; atomic-run breaks it into manageable molecules for rapid, auditable execution.

Quick Start

Initiate the atomic-run process on a plan file to execute it atom-by-atom, grouped into molecules for review.

Frequently Asked Questions about atomic-run

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

FAQPage Schema
How do I execute a plan step-by-step with automated reviews?

Executing a plan step-by-step with automated reviews involves parsing tasks into molecules, processing atoms sequentially, and generating concise commit-style summaries for approval after each molecule batch.

What is molecule-based sequential automation for plan execution?

Molecule-based sequential automation is an execution process that groups plan steps into review-friendly molecule batches by cognitive weight, ensuring deterministic, auditable implementation while minimizing cognitive load.

How does automated plan parsing categorize tasks by cognitive weight?

Automated plan parsing categorizes tasks by cognitive weight by evaluating complexity as mechanical, light, or cognitive, then grouping atoms into appropriately sized molecules for balanced execution.

Can I use sequential automation for large implementation roadmaps?

You can use sequential automation for large implementation roadmaps because the molecule-based execution approach scales to handle plans of varying complexity, from small task lists to large roadmaps.

What's the best way to group plan steps into review-friendly batches?

The best way to group plan steps into review-friendly batches is using weight-based molecule grouping, which categorizes atoms by cognitive complexity to balance execution speed and reviewability.

When should I not use atom-by-atom plan execution?

You should avoid atom-by-atom plan execution when your project requires immediate simultaneous deployment without intermediate reviews, as this approach enforces sequential processing and mandatory molecule-level approval checkpoints.