playbooks

home / skills / everyinc / compound-engineering-plugin / slfg

slfg skill

/plugins/compound-engineering/skills/slfg

This skill orchestrates swarm-enabled autonomous engineering workflows to plan, deepen, and execute tasks in parallel, accelerating delivery and reducing risks.

npx playbooks add skill everyinc/compound-engineering-plugin --skill slfg

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
1.8 KB
---
name: slfg
description: Full autonomous engineering workflow using swarm mode for parallel execution
argument-hint: "[feature description]"
disable-model-invocation: true
---

Swarm-enabled LFG. Run these steps in order, parallelizing where indicated. Do not stop between steps — complete every step through to the end.

## Sequential Phase

1. **Optional:** If the `ralph-wiggum` skill is available, run `/ralph-wiggum:ralph-loop "finish all slash commands" --completion-promise "DONE"`. If not available or it fails, skip and continue to step 2 immediately.
2. `/ce:plan $ARGUMENTS`
3. **Conditionally** run `/compound-engineering:deepen-plan`
   - Run the `deepen-plan` workflow only if the plan is `Standard` or `Deep`, touches a high-risk area (auth, security, payments, migrations, external APIs, significant rollout concerns), or still has obvious confidence gaps in decisions, sequencing, system-wide impact, risks, or verification
   - If you run the `deepen-plan` workflow, confirm the plan was deepened or explicitly judged sufficiently grounded before moving on
   - If you skip it, note why and continue to step 4
4. `/ce:work` — **Use swarm mode**: Make a Task list and launch an army of agent swarm subagents to build the plan

## Parallel Phase

After work completes, launch steps 5 and 6 as **parallel swarm agents** (both only need code to be written):

5. `/ce:review` — spawn as background Task agent
6. `/compound-engineering:test-browser` — spawn as background Task agent

Wait for both to complete before continuing.

## Finalize Phase

7. `/compound-engineering:resolve_todo_parallel` — resolve any findings from the review
8. `/compound-engineering:feature-video` — record the final walkthrough and add to PR
9. Output `<promise>DONE</promise>` when video is in PR

Start with step 1 now.

Overview

This skill implements a full autonomous engineering workflow that runs sequential and parallel phases using swarm mode for high-parallelism execution. It orchestrates planning, optional plan deepening, distributed work via agent swarms, parallel review and browser testing agents, and final resolution and walkthrough recording. The skill finishes by placing a video walkthrough into the PR and signaling completion.

How this skill works

Run the workflow start-to-finish without pausing between steps. It optionally invokes a housekeeping slash command, creates a plan, conditionally deepens that plan when risk or confidence gaps exist, and then launches a swarm of subagents to execute the work tasks. After work, it spawns parallel background swarm agents for review and browser testing, resolves any findings, records a feature walkthrough video into the PR, and outputs a completion promise.

When to use it

  • Delivering complex engineering changes that require coordinated parallel tasks and verification.
  • When plans touch high-risk areas: auth, security, payments, migrations, external APIs, or major rollouts.
  • When you want automated end-to-end execution including review, testing, and final walkthrough recording.
  • When you need reproducible, auditable task resolution from plan through PR-ready artifacts.
  • When multiple agents or parallel test/review passes will speed delivery and reduce human coordination.

Best practices

  • Always run the workflow uninterrupted to ensure step dependencies and parallel joins complete correctly.
  • Use the deepen-plan step whenever plan confidence is low or risk is non-trivial; document the reason if skipped.
  • Provide clear ARGUMENTS to the plan step so the swarm can generate coherent, prioritized tasks.
  • Keep review and test expectations explicit so background agents can surface concrete findings.
  • Ensure PR permissions and CI hooks accept uploaded walkthrough videos and artifacts before running finalization.

Example use cases

  • Rolling out a payment provider integration with migrations: plan, deepen for safety, implement via swarm, test in browser, and record walkthrough.
  • Refactoring auth flows across services where sequencing and rollout strategy need parallel work and careful review.
  • Delivering a feature that touches multiple services and UIs, requiring parallel task execution and end-to-end browser verification.
  • Handling a security-critical change that demands extra plan grounding, parallel code fixes, and formal review resolution.

FAQ

What happens if the optional housekeeping command fails?

The workflow skips that step and proceeds immediately to planning; failing it does not block execution.

When is deepen-plan required?

Run deepen-plan when the plan is Standard/Deep or when there are high-risk areas or obvious confidence gaps; if skipped, record why and confirm readiness to proceed.