grace-execute

Execute GRACE development plan steps sequentially with verification and commits.

233|51|Updated Feb 17, 2026
One-click install
npx skills add https://github.com/osovv/grace-marketplace --skill grace-execute
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: grace-execute
Source: https://github.com/osovv/grace-marketplace/tree/main/skills/grace/grace-execute
Command: npx skills add https://github.com/osovv/grace-marketplace --skill grace-execute

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Orchestrates end-to-end, sequential implementation of a GRACE development plan so modules are generated, verified, and committed in a controlled, dependency-safe order, preventing drift and broken builds caused by parallel or uncoordinated work.

Core Features & Use Cases

  • Controller-driven execution queue: parse development-plan.xml and knowledge-graph.xml once and build compact execution packets for each step.
  • Scoped generation and verification: generate code per-step, run step-level verification and scoped reviews, and escalate only when broader drift is detected.
  • Atomic commits and graph sync: commit module implementations immediately after verification and update the shared knowledge graph and plan artifacts centrally.
  • Use Case: Ideal for finishing a small set of high-dependency modules, performing risk-averse delivery waves, or maintaining strict knowledge-graph integrity in large repos.

Quick Start

Run the grace-execute skill to sequentially process the approved execution queue and commit each validated module implementation.

Frequently Asked Questions about grace-execute

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

FAQPage Schema
How do I execute a development plan sequentially to prevent dependency drift?▼

Sequential execution of a development plan involves processing ordered phases step-by-step, generating and verifying modules individually, and committing them immediately to prevent drift and broken builds caused by uncoordinated work.

When should I use sequential module execution instead of parallel waves?▼

Sequential module execution is necessary when dependency risk makes parallel waves unsafe, requiring strict knowledge-graph integrity and controlled, dependency-safe ordering to generate and commit modules without breaking builds.

How do code generation and git commits work with a knowledge graph?▼

Code generation applies step-level verification against a parsed knowledge graph, proposing graph deltas and committing module implementations immediately after validation to synchronize shared plan artifacts centrally.

What files are required to sequentially execute and commit development steps?▼

Sequential execution requires parsed docs/development-plan.xml and docs/knowledge-graph.xml files defining ordered phases and steps, along with controller-managed execution packets to process the approved queue.

What is the best way to maintain knowledge-graph integrity in large repositories?▼

Maintaining knowledge-graph integrity in large repositories requires scoped step-level verification, atomic commits immediately after validated generation, and centralized updates to shared graph and plan artifacts after each module.

Does scoped code generation limit verification to individual modules?▼

Scoped code generation runs step-level verification and scoped reviews per module, escalating only when broader dependency drift is detected across the sequentially executed development plan phases.