everyinc/compound-engineering-plugin

lfg

Take a request all the way to done, hands-off, through the right Compound Engineering skills.

소스 보기

사용 방법

  1. 설치 명령을 복사하고 자신의 에이전트 환경에 설치하기 전에 소스 패키지를 확인하세요.
  2. 필요한 도구, 인증 정보, 지원 환경은 원본 문서에서 확인하세요.
  3. 입력과 원하는 산출물을 설명하고 출처와 결과를 대조하세요.
npx skills add https://github.com/everyinc/compound-engineering-plugin --skill lfg

시작 전 확인

  • 설치에는 모델 구독, API 한도, 파일 접근 권한이 포함되지 않습니다.
  • 별점 수와 설치 수는 활동 지표이며 독립적인 품질·보안 검증이 아닙니다.
원본 Skill 문서

원본 저장소의 제목, 예시, 코드, 표, 링크, 이미지를 유지해 표시합니다.

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.

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 owns any goal-mode choice and returns control.
  1. 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.
  1. 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.
  1. 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.
  1. 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.
  1. 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.
  1. Invoke the ce-test-browser skill with mode:pipeline.
  1. Read `references/shipping.md` first; it governs steps 9 through 11. Then invoke the ce-commit-push-pr skill with mode:pipeline branding:on.
  1. 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.
  1. Output <promise>DONE</promise> after the close-out in references/shipping.md.

관련 작업

같은 저장소의 Skills

더 많은 Skills

모든 Skills
everyinc
커뮤니티

ce-compound

Capture a solved problem's lesson in its cheapest durable form, a test or lint rule, a coding standard, or a repo learning, or refresh existing learnings against the codebase. Use when verified work corrected a wrong belief about how something behaves, such as a failed approach, a real defect a review caught, or a wrong assumption or document, or when auditing stale, overlapping, or drifted learnings. Do not auto-invoke it for work that went as first planned.

1시간 설치 수
1
GitHub Stars
2.6만
업데이트
11월 18일
everyinc
커뮤니티

ce-plan

Create structured plans for multi-step work, including software and non-software tasks. Use when asked to plan, break down implementation, plan from requirements, or deepen an existing plan; prefer ce-brainstorm for exploratory framing.

1시간 설치 수
1
GitHub Stars
2.6만
업데이트
11월 18일
everyinc
커뮤니티

ce-setup

Check Compound Engineering's tools and repo config and fix what it finds, scaffold a Compound Pack with pack: , or draft and refresh coding standards and review docs from pull request history. Use when setting up or diagnosing Compound Engineering, or when creating or updating CODINGSTANDARDS.md or REVIEW.md, including on a schedule.

1시간 설치 수
1
GitHub Stars
2.6만
업데이트
11월 18일
everyinc
커뮤니티

ce-simplify-code

Simplify code for clarity, reuse, quality, and efficiency while preserving behavior, and prune tests and comments that carry no value. Use after implementation and before review, or to audit tests or comments in any part of a repo; use ce-debug for bugs.

1시간 설치 수
1
GitHub Stars
2.6만
업데이트
11월 18일