跳至正文
OpenAgentSkill
浏览已开放 · 目录记录日期 2026-11-21 · 自动更新和账户服务暂时关闭。
开发与测试

graph-engineering

WHEN orchestrating interdependent specs, stories, or work items across agents—deciding what runs serially, what may run in parallel, and how each unit is independently verified; NOT for single-task delegation, code review, or PR delivery mechanics; returns a contract-first execution graph with a per-node verifier.

mintuz · 已有静态检查记录

安装与使用

运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。

npx skills add mintuz/skills --skill graph-engineering

技能说明


name: graph-engineering description: WHEN orchestrating interdependent specs, stories, or work items across agents—deciding what runs serially, what may run in parallel, and how each unit is independently verified; NOT for single-task delegation, code review, or PR delivery mechanics; returns a contract-first execution graph with a per-node verifier.

Graph Engineering

A fan-out is not a graph. Launching N agents at one scope is scatter-gather; a graph exists only when some units depend on, inform, or exclude others, and then the ordering is the work. The graph has: a verification contract fixed before any node runs, nodes cut at judging seams, edges that state why order matters, a schedule that defaults to serial and earns every concurrency, one independent verifier per node, and a render the user approves before the first dispatch.

  • The contract precedes the artifact. Define correctness before implementation, or implementation defines correctness and every later check merely confirms it (principle-fix-the-bar-first).
  • Whoever built it does not judge it. Every node is judged by a fresh context that never saw the building (principle-judge-with-fresh-eyes).
  • Concurrency is an exception with evidence. Serial is the default because conflicting edits, duplicated work, and divergent decisions cost more than the wall-clock they save (principle-sequence-verifiable-units).

Build a graph only when there are edges to schedule: one unit depends on or is informed by another's result, or two units share a write scope or a single-writer resource. When no unit writes and none depends on another, run the units as plain concurrent reads and return their results — no contract, no ledger, no verifier seat, no heartbeat (principle-subtract-before-you-add). One unit of work in one context is not a graph, and no structure rescues a goal that was never fixed.

Roles

RoleOwnsNever
Orchestratorcontract, cut, edges, schedule, integration, re-planningimplements a node's artifact, or judges one
Workerone node's artifact and its raw evidencejudges its own work, or decides ordering
Verifierone node's verdict against the contractedits the artifact, or reads the worker's reasoning
Heartbeatusage headroom, the pause trigger, the resume scheduleimplements, judges, or re-plans a node

Compose each agent from skills, not one skill per agent. A node's brief names one lead skill governing its method, plus supporting skills governing the other aspects it touches — language, domain, testing, delivery. Skills compose when they govern different aspects and conflict when they govern the same one; two skills that both claim the method are two nodes, or a choice between them. Name the composition in the brief and record it in the ledger: it is part of what produced the artifact.

1. Fix the verification contract

Fetch the remote first: an hours-old local view is not evidence of what the base branch contains or lacks, and a spec cut on a stale view invalidates every node behind it (principle-refresh-before-resuming). Then read the specs, stories, issues, and repository rules that govern the run, and record each source's locator and revision as fetched. When the run names several specs, confirm their full priority order with the user before cutting any node. Record a conflict between the user's latest message and an earlier ledger as an open question; never resolve it by choosing one (principle-rank-sources-by-authority).

Derive the contract before cutting any node: every in-scope normative statement becomes one independently decidable assertion, stated as an observable outcome rather than an implementation. Preserve each assertion's source identifier. Record conflicting or missing authority as an open question, never as a silent assumption.

Split the contract into two lanes, verified differently:

LaneAssertion formVerified by
StaticA property of the artifact: types, structure, checks, conventionsRunning the checks and reading the artifact
BehavioralAn outcome a user or caller observes end to endExercising the running system

Within the behavioral lane, mark each assertion as gate-judged or reference-judged. A gate holds or it does not. A reference-judged assertion is a matter of degree — fidelity to a supplied baseline such as a design export or reference screenshot — and the baseline is a governing source: record its locator and revision. A reference-judged assertion is undecidable until the contract also fixes its materiality threshold (what counts as close enough — layout fidelity or pixel identity) and its capture protocol (viewport, theme, seed data, animation state — whatever makes the comparison reproducible). Fix both here, never mid-verification (principle-fix-the-bar-first).

An assertion that no lane can verify is a contract gap, and it stays visible until closed (principle-gaps-are-not-passes).

Complete when: every governing source is recorded with its revision, every in-scope statement maps to exactly one assertion in a named lane, every reference-judged assertion carries its baseline revision, threshold, and capture protocol, and every ambiguity is an open question rather than a guess.

2. Cut the nodes

A node exists where there is a judging seam — an artifact that can be verified against its own assertions without waiting for the rest of the graph — and a bounded write scope. Both, or it is not a node.

For each node record: identifier, owned assertions, owned paths, lead and supporting skills, deliverable, and non-goals. Keep tightly coupled work in one node; splitting work that cannot be judged apart costs a handoff and buys nothing.

For a change to existing code, render the shape with pseudocode before cutting. Owned paths and module boundaries read from the source hold up at dispatch; ones inferred fr

阅读完整来源 ↗