New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

LFG Autonomous Delivery

by EveryInc in EveryInc/compound-engineering-plugin

Takes a request all the way through without stopping, routing it to Compound Engineering skills so that a code change ends as an open pull request.

MITAuto-check passedAgent Workflows

Install LFG Autonomous Delivery

skills CLI
$ npx skills add EveryInc/compound-engineering-plugin --skill lfg -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install EveryInc/compound-engineering-plugin lfg --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/EveryInc/compound-engineering-plugin.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/lfg .claude/skills/lfg && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
lfg
GitHub stars
25k
Token cost
~2k tokens
SKILL.md length
1,113 words
Files
11 (incl. references)
Skills in repo
37
Repo updated
First seen
Licence
MIT

At a glance

Takes a request all the way through without stopping, routing it to Compound Engineering skills so that a code change ends as an open pull request.

  • Works in 4 steps: Produce the work source per… → Read references/work-return.md first,… → Read references/review-followup.md now;… → …
  • You want a request carried through to an open pull request with no check-ins
  • Calls git
  • Handing a concrete bug report to an autonomous plan, fix and ship pipeline

What it does

Used only when you explicitly ask for hands-off end-to-end work or invoke `lfg`, the skill routes a request to the Compound Engineering skill whose job it is, and most requests end with that skill's result. A code change gets the longest path: it is implemented, simplified, reviewed with eligible findings applied and the rest recorded, any durable learning captured, then committed and pushed, ending in an open PR whose URL the agent holds and whose CI is decided. Merging stays with you unless you granted it for the run.

Code changes need a verified work source: an implementation-ready plan that `ce-work` implements, or a `fixed` return from `ce-debug`. The agent never searches the plans folder for a candidate or plans from scratch over an existing plan. Routing sends a plan path to the plan route, a concrete failure report to `ce-debug`, an unsettled judgment to `ce-pov` first, ambiguous product shape to `ce-brainstorm` (or `ce-plan` in pipeline mode), non-code results to the skill that owns them, and any other code change to `ce-plan`. Reference files define intake, stage routing, shipping and review follow-up.

When your agent uses it

  • You want a request carried through to an open pull request with no check-ins
  • Handing a concrete bug report to an autonomous plan, fix and ship pipeline
  • Routing a mixed request to the right Compound Engineering skill automatically

Example prompts

  • “lfg: add rate limiting to the public search endpoint and open the PR.”
  • “Run this fully autonomous: fix the failing checkout test and push it up as a pull request.”
  • “Take the plan we just wrote with ce-plan and ship it hands-off.”

Requirements

  • The Compound Engineering skills such as `ce-plan`, `ce-work`, `ce-debug` and `ce-commit-push-pr`
  • A repository remote that can receive a pushed branch

Workflow steps

4 steps, taken from the first numbered list in SKILL.md.

  1. Produce the work source per references/intake.md. On the plan route, read references/plan-brief.md first; it alone defines the…
  2. Read references/work-return.md first, then invoke the ce-work skill with mode:return-to-caller . On the defect route this step does not…
  3. Read references/review-followup.md now; it governs steps 3 through 7. Invoke the ce-simplify-code skill on the branch diff; skip only the…
  4. Invoke the ce-code-review skill with mode:agent plan:; on the defect route omit plan:. A settled_conflict finding whose evidence shows the…

What it can do on your machine

Read from SKILL.md and the folder at commit 67035e9. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • git

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use git, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

LFG Autonomous Delivery loads about 2k tokens when it runs, and up to ~19k if it reads all its reference files. Until then it costs about 89 tokens; SKILL.md has 1,113 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~89
When it runs · the whole SKILL.md, loaded when a task matches
~2k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~19k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from EveryInc/compound-engineering-plugin at commit 67035e9, republished under its MIT licence (© EveryInc). 1,113 words, ~1,974 tokens.

Download SKILL.mdSave it as .claude/skills/lfg/SKILL.md (or your agent's skills folder). This skill also uses 10 other files; get the full folder from GitHub.
name
lfg
description
Take a request all the way to done, hands-off, through the right Compound Engineering skills. A code change ends as an open pull request, pushed without stopping. Use only when the user explicitly asks for autonomous end-to-end work or invokes lfg directly. Use ce-plan, ce-work, ce-debug, or ce-commit-push-pr for work the user reviews step by step.
argument-hint
[feature, bug, issue reference, or plan path; optionally assign planning and/or implementation to a model or harness]

Outcome. The request reaches the end state its shape calls for, produced by the Compound Engineering skill whose job that is, with everything unresolved recorded where the user will see it. Most requests end with that skill's result and no branch. A change to the code is the one shape with more steps of its own: it ends in an open pull request whose URL you hold, with CI decided, after being implemented, simplified, reviewed with the eligible findings applied and the rest recorded, any durable learning captured, committed, and pushed. Merging stays with the user unless they granted it for this run.

Work source. On the routes that change the code, nothing is implemented without a work source verified this run, and only two things qualify: an implementation-ready plan, which ce-work implements; or a fixed return from ce-debug, where the fix is the implementation. The plan is one the session identifies, as references/intake.md defines. Never search the plans directory for a candidate or act on a file you discovered. Never plan from scratch over an existing plan.

Route by what the request is. Match the request to the skill whose job it is; the host's skill list is the catalog. Read references/intake.md before choosing; it alone defines the routes, their precedence, what each child skill is passed, and how each return is read. In short:

  • A plan path, or a plan ce-plan wrote this session, takes the plan route.
  • A concrete report of failing or wrong behavior goes to ce-debug; reproducing it is that skill's job, not intake's.
  • A change that hangs on a judgment the user did not settle goes to ce-pov first, and only a verdict that supports the change continues; a judgment with nothing to build ends at the verdict.
  • Product shape with more than one plausible reading goes to ce-brainstorm when a human is present, and to ce-plan in pipeline mode when not.
  • A request whose result is not a code change goes to the skill that owns that result (ce-explain, ce-prototype, ce-pov, ce-ideate, and so on); that invocation is the whole run: return its result and end.
  • Any other change to the code goes to ce-plan.

When unsure, take the route that asks more of the evidence.

Interaction. Ask the user only through ce-brainstorm, and only when a human is present. Everything else proceeds without waiting: reversible work is done and shown for the user to correct afterward, and only an irreversible action outside what they granted (a merge they did not grant, a force-push, deleting data) stops instead. lfg runs from schedulers, loops, and nested orchestrators. The one other question is the routing disambiguation references/stage-routing.md defines: when the conversation assigns planning or implementation to a model or harness, read that file before routing; it alone carries the carrier strings and the sanitization.

Stop, and say why, when any of these holds:

  • The work source cannot be produced: planning returned blocked, the diagnosis found no safe fix, the fix would be divergent, ce-pov did not support the change, or a stage assignment cannot be passed on.
  • A child return is anything but complete and evidenced.
  • A settled decision is invalidated.
  • A project-defined shipping process falls short.

A stop leaves nothing pushed that was not already pushed.

Resolve every skill named here against the host's available-skills list and invoke that exact entry; some hosts namespace it (compound-engineering:ce-plan). Read references/task-visibility.md before starting: it defines the stage view published through the platform's task-tracking capability, the chat narration, and the completion rule that a step is done only after it ran, a child skill's return resumes the next numbered step in the same turn, and the turn does not end before DONE or a stop.

Show full SKILL.md (496 more words)Show less

The run (routes that change the code)

  1. Produce the work source per references/intake.md. On the plan route, read references/plan-brief.md first; it alone defines the settled-decisions brief and the artifact-root rule. Any explicit status: blocked return, including settled-decision-invalidated, stops the run. Blocked status outranks an existing artifact and is never retried. Only absence of both a blocker and a plan file ce-plan reported writing this run invokes ce-plan a second time with the same arguments, reusing the composed brief verbatim; the plan must then pass the readiness check in references/plan-brief.md. On the plan route the plan_model:<alias> carrier rides beside the request when a planning-stage directive resolved. Record the work source for every later step. LFG never launches /goal directly; ce-work implements and returns control.

  2. Read references/work-return.md first, then invoke the ce-work skill with mode:return-to-caller <plan-path-from-step-1>. On the defect route this step does not run: ce-debug already implemented and committed, and references/debug-return.md was its gate. Only a valid status: complete may advance; every other status or malformed return stops the pipeline.

  3. Read references/review-followup.md now; it governs steps 3 through 7. Invoke the ce-simplify-code skill on the branch diff; skip only the invocation for a docs-only or roughly sub-10-line change.

  4. Invoke the ce-code-review skill with mode:agent plan:<plan-path-from-step-1>; on the defect route omit plan:. A settled_conflict finding whose evidence shows the settled decision cannot work (infeasible, wrong-thing, or destructive) stops the pipeline as blocked, with the finding reported, before the shipping precondition.

Shipping precondition (every push from step 5 on). Run git remote once. No remote means local-only: make every commit the steps call for, but skip every push, PR create/edit, and CI-watch action, including step 10 in full. That is terminal, not an error.

  1. Apply and persist review fixes as that file defines. Do not proceed to the residual handoff, run browser tests, or output DONE while eligible review fixes remain only in the working tree uncommitted.

  2. Autonomous residual handoff: whenever an unapplied actionable finding, a settled_conflict stamp from step 4, or a proceeded-and-flagged settled_decision_conflicts entry from step 2 exists, record it durably per that file: in the PR body, or in tickets or the DONE report when no PR will exist. Skip only when none of the three exists. Do not output DONE until the residuals are durable. Never block DONE on tracker filing failures once the report states them. Do not prompt the user.

  3. Invoke the ce-compound skill with mode:non-interactive when the run produced durable reasoning the code, tests, and plan do not carry; that file states the full condition. Documentation skipped is success; running here puts the learning in the PR at open.

  4. Invoke the ce-test-browser skill with mode:pipeline.

  5. Read references/shipping.md first; it governs steps 9 through 11. Then invoke the ce-commit-push-pr skill with mode:pipeline branding:on.

  6. Watch the PR to CI-decided with ce-babysit-pr mode:pipeline <pr-url> when an open PR exists, as references/shipping.md decides. Do not reimplement CI-watching here.

  7. Output <promise>DONE</promise> after the close-out in references/shipping.md.

© EveryInc, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 10 other files (references) in skills/lfg of EveryInc/compound-engineering-plugin.

  • SKILL.md
  • references/debug-return.md
  • references/intake.md
  • references/next-work-handoff.md
  • references/plan-brief.md
  • references/review-followup.md
  • references/shipping.md
  • references/stage-routing.md
  • references/task-visibility.md
  • references/tracker-defer.md
  • references/work-return.md

Open the folder on GitHubat commit 67035e9

Compare with similar skills

LFG Autonomous Delivery next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

LFG Autonomous Delivery compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
LFG Autonomous Delivery this skillEveryInc/compound-engineering-plugin25k—~2kAutomated safety check: PassMIT
Context Mode Opsmksglu/context-mode26k—~6kAutomated safety check: PassCustom licence
PRP LoopWirasm/prp2.3k—~894Automated safety check: PassMIT
Self-Improve Evolutionary LoopYeachan-Heo/oh-my-claudecode40k—~5.3kAutomated safety check: WarnMIT
PRP Loop: Autonomous PipelineWirasm/prp2.3k—~863Automated safety check: PassMIT
PRP Workstream OrchestratorWirasm/prp2.3k—~3.5kAutomated safety check: PassMIT

Similar skills

  • Context Mode Ops

    mksglu/context-mode

    Runs maintenance for the context-mode project with parallel subagents: issue triage, PR review, releases, bug fixes, announcements and branch syncing.

    26k GitHub stars~6k tokensUpdated yesterday
    Agent WorkflowsAuto-check passed

  • PRP Loop

    Wirasm/prp

    Runs the plan, implement and review pipeline detached in fresh headless sessions, looping review and fix until the pull request is clean.

    2.3k GitHub stars~894 tokensUpdated 6 days ago
    Agent WorkflowsAuto-check passed

  • Self-Improve Evolutionary Loop

    Yeachan-Heo/oh-my-claudecode

    Runs an autonomous improvement loop on a repository: agents propose and execute plans, a tournament picks the winner by benchmark, and each round is recorded and plotted.

    40k GitHub stars~5.3k tokensUpdated today
    Agent WorkflowsAuto-check: warnings

  • PRP Loop: Autonomous Pipeline

    Wirasm/prp

    Runs a detached, resumable loop that plans, implements, opens a PR, reviews and fixes a feature across headless CLI sessions until the review is clean.

    2.3k GitHub stars~863 tokensUpdated 6 days ago
    Agent WorkflowsAuto-check passed

  • PRP Workstream Orchestrator

    Wirasm/prp

    Coordinates several PRP workstreams in isolated Git worktrees from one session, verifying proof, holding merge gates and sequencing the merges.

    2.3k GitHub stars~3.5k tokensUpdated 6 days ago
    Agent WorkflowsAuto-check passed

  • Aicr Cross Review

    NVIDIA/aicr

    Official

    Multi-agent PR review using Claude Code, Codex, and CodeRabbit.

    439 GitHub stars~15k tokensUpdated today
    Agent WorkflowsAuto-check passed

More from EveryInc/compound-engineering-plugin

All 37 skills in this repo

  • Compound Learning Writer

    EveryInc/compound-engineering-plugin

    Records one solved and verified problem as a durable learning in the repository, but only when the reasoning is not already clear from the final code, tests or docs.

    25k GitHub stars~2k tokensUpdated today
    Auto-check passed

  • Compound Learnings Refresh

    EveryInc/compound-engineering-plugin

    Audits a repo's stored learnings against the current codebase, fixes stale, overlapping or superseded docs and reports on every document.

    25k GitHub stars~2k tokensUpdated today
    Auto-check passed

  • Compound Engineering Prototype

    EveryInc/compound-engineering-plugin

    Builds a throwaway prototype at just the fidelity needed to settle a specific how-it-should-work-or-feel question, before committing to an approach other work will treat as fixed.

    25k GitHub stars~1.9k tokensUpdated today
    Auto-check passed

  • Compound Engineering Setup

    EveryInc/compound-engineering-plugin

    Checks Compound Engineering plugin health and repo-local config, or scaffolds a Compound Pack when you ask for one by id.

    25k GitHub stars~2k tokensUpdated today
    Auto-check passed

  • PR Babysitter

    EveryInc/compound-engineering-plugin

    Watches an open GitHub pull request over time, routing review comments and CI failures to other skills until the PR is ready to merge.

    25k GitHub stars~2k tokensUpdated today
    Auto-check passed

  • CE Brainstorm

    EveryInc/compound-engineering-plugin

    Turns a vague or ambitious feature idea into a requirements-only plan through dialogue with you, sized to the work, before any code is written.

    25k GitHub stars~1.9k tokensUpdated today
    Auto-check passed

Categories

Questions about LFG Autonomous Delivery

What does LFG Autonomous Delivery do?

Takes a request all the way through without stopping, routing it to Compound Engineering skills so that a code change ends as an open pull request. Used only when you explicitly ask for hands-off end-to-end work or invoke `lfg`, the skill routes a request to the Compound Engineering skill whose job it is, and most requests end with that skill's result. A code change gets the longest path: it is implemented, simplified, reviewed with eligible findings applied and the rest recorded, any durable learning captured, then committed and pushed, ending in an open PR whose URL the agent holds and whose CI is decided.

When should I use LFG Autonomous Delivery?

LFG Autonomous Delivery fits situations like: you want a request carried through to an open pull request with no check-ins; handing a concrete bug report to an autonomous plan, fix and ship pipeline; routing a mixed request to the right Compound Engineering skill automatically.

How do I install LFG Autonomous Delivery in Claude Code?

Run `npx skills add EveryInc/compound-engineering-plugin --skill lfg -a claude-code`. Or copy the skill folder (skills/lfg in EveryInc/compound-engineering-plugin) into .claude/skills/lfg in your project. Claude Code loads it when a task matches its description.

How do I install LFG Autonomous Delivery in Codex?

Run `npx skills add EveryInc/compound-engineering-plugin --skill lfg -a codex`. Or copy the skill folder (skills/lfg in EveryInc/compound-engineering-plugin) into .agents/skills/lfg in your project. Codex loads it when a task matches its description.

Can I use LFG Autonomous Delivery in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add EveryInc/compound-engineering-plugin --skill lfg -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/lfg, .gemini/skills/lfg, .github/skills/lfg and .opencode/skills/lfg in your project.

What does LFG Autonomous Delivery need to run?

Going by SKILL.md and its folder, LFG Autonomous Delivery needs the command-line tools its instructions call (git). Our summary lists: The Compound Engineering skills such as `ce-plan`, `ce-work`, `ce-debug` and `ce-commit-push-pr`; A repository remote that can receive a pushed branch.

Does LFG Autonomous Delivery access the network?

SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is LFG Autonomous Delivery safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does LFG Autonomous Delivery use?

LFG Autonomous Delivery is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does LFG Autonomous Delivery use?

About 2k tokens (SKILL.md is roughly 7.9k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 17k tokens, read only when the agent opens those files.

What are the alternatives to LFG Autonomous Delivery?

Skills that share tags, products or a category with LFG Autonomous Delivery: Context Mode Ops (mksglu/context-mode, 26k stars), PRP Loop (Wirasm/prp, 2.3k stars), Self-Improve Evolutionary Loop (Yeachan-Heo/oh-my-claudecode, 40k stars) and PRP Loop: Autonomous Pipeline (Wirasm/prp, 2.3k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains LFG Autonomous Delivery?

EveryInc (a GitHub organization) maintains it in EveryInc/compound-engineering-plugin, which has 25,424 GitHub stars. The repository holds 37 skills in this directory. The repository was last updated on October 8, 2026.

Source: EveryInc/compound-engineering-plugin on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.