Linear scrum
Take a dev-flow project into Linear and run it with agile scrum. Creates/links a Linear Project under the workspace team, pushes `.workflow/tasks.md` into issues (story-point estimates, `area:web`/`area:agent` labels, milestones), sets up cycles/sprints (2-week cadence), and keeps Linear as the source of truth: sync pushes only new tasks, pulls status/velocity, plans the active sprint up to the velocity target, and reports. Triggers: "porta il progetto in Linear", "crea le issue in Linear", "setup scrum", "pianifica lo sprint", "report di velocity", "adotta questo progetto in Linear", or dev-flow routing from `prd_drafted`/`tasks_split`. Modes: Setup (new project), Adopt (existing Linear project), Sync (ongoing). Not for: writing or estimating the tasks themselves (use `prd-to-tasks`), building the app or agent (use design-md-to-app / eve-agent), or the headless server loop wiring (see docs/loop-engineering.md).From its SKILL.md
npx -y skills add lukedj78/dev-flow --skill linear-scrumAssembled from the repository path, not quoted from the project. Check it against their README if it does not work.
3 things to look at
- reads credentialsReads from 1 credential source: `docs/loop-engineering.md`.
- 4 stars4 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.
- runs commandsInstructs the agent to run 3 commands, including `python3 scripts/meta_linear.py <root>/.workflow/meta.json upsert-linear` and 2 more.
SKILL.md
6.9 KB, ~1.5k tokens by cl100k_base, as published. Nobody here has run it
linear-scrum — Linear integration + agile scrum for a dev-flow project
This skill owns the Linear side of a dev-flow project. It writes to Linear (via the connected Linear MCP) and to the linear / scrum blocks of .workflow/meta.json. It never touches app/, apps/agent/, or other framework files, and it does not change the phase enum — like eve-agent and the discipline skills it records state in meta.json and appends history, and is never a phase gate.
Read references/contracts.md for the .workflow/ contract, references/scrum-model.md for the scrum conventions, and references/linear-mcp.md for the exact Linear MCP operations.
Preconditions
- A Linear MCP must be connected in the session. Confirm with
list_teamsbefore any write. For the headless server loop use the API-key path indocs/loop-engineering.mdinstead — this skill is the interactive counterpart. .workflow/meta.jsonexists (dev-flow project). If not, tell the user and stop..workflow/tasks.mdexists for Setup mode (runprd-to-tasksfirst otherwise). Coupled format:scripts/task_key.pyderives its dedup key from the- [ ] **<Title>** — <body>line shape produced byprd-to-tasks, splitting on the em-dash (—) to isolate the title — iftasks.mdwas hand-edited to use a different separator, dedup breaks and Setup/Sync can create duplicate issues.
Read state, then pick a mode
Read .workflow/meta.json:
- No
meta.json#linearandtasks.mdpresent → Setup mode. - A Linear Project already exists for this project but
meta.json#linearis absent/partial → Adopt mode. meta.json#linearpresent → Sync mode.
Do one logical operation per invocation, then stop. Every mode is idempotent.
Setup mode (new project)
list_teams→ resolve the team (single team today:Lucadigerlando). One dev-flow project = one Linear Project under that team, never a new team.- Ensure scrum config on the team:
- Estimates — verified working:
save_issueaccepts a Fibonacciestimate(numeric point value) when the team has an estimate scale enabled. - Cycles — the MCP can only list cycles (
list_cycles), not create them. Ask the user to enable "Cycles" in Linear team settings once and create the first cycle there, then continue; issues are attached to an existing cycle viasave_issue'scyclefield.
- Estimates — verified working:
- Create/link the Linear Project (
save_project); capture its id + url. - Push
tasks.md→ issues (save_issue), one per- [ ]task:- estimate: from the task's
Estimated:hint mapped to the nearest Fibonacci point; for tasks with no hint, batch-prompt once (list them, ask for points in one message) and default to unestimated if skipped. - labels: discover, don't assume. Call
list_issue_labelsand map the conceptual buckets — web / agent / scaffold — onto the workspace's own labels (e.g. this workspace usesfrontend/agent-eve/setup, notarea:*). Derive web-vs-agent frommeta.json#stack+ the task's*(addressed by …)*tag; record the resolved mapping inmeta.json#scrum.labels. Create a label only if no reasonable match exists. - milestone: map epics/milestones via
save_milestonewhentasks.mdgroups by epic. - record each
task_key(line) → issue identifierfor the next step.
- estimate: from the task's
- Attach issues to the active cycle if one exists (
list_cycles; the cycle itself is created in Linear per step 2 — 2-week cadence). If none exists yet, leave the issues in the backlog and note it. - Persist state:
Then append apython3 scripts/meta_linear.py <root>/.workflow/meta.json upsert-linear \ --team-id <id> --team-name <name> --project-id <pid> --url <url> python3 scripts/meta_linear.py <root>/.workflow/meta.json record-issues \ --mapping '{"<task_key>":"LUC-123", ...}'historyentry viadev-flow/scripts/update_meta.py:{ "skill": "linear-scrum", "action": "setup", "ran_at": "<ISO8601>" }(no phase bump).
Adopt mode (existing project already partly in Linear)
- Discover the existing Project and its issues (
list_projects,list_issues). - Match issues to
tasks.mdlines by title (task_key) and backfillissue_mapwithout creating anything (meta_linear.py record-issues). - Fill any missing scrum config (
meta_linear.py ensure-scrum), thenupsert-linearwith the discovered project id/url. - Append history
{ "skill": "linear-scrum", "action": "adopt", … }.
Sync mode (ongoing, horizontal)
- Push new tasks: for each
tasks.mdline whosetask_keyis not inissue_map,save_issue+record-issues. Never edit or re-push existing issues — Linear owns status/ordering/estimates. - Pull status/velocity: read issue states + completed points from Linear (
list_issues,list_cycles). - Sprint planning: move items from
Backlog/Todointo the active cycle up to the velocity target (meta.json#scrum.velocity_target; learned from past cycles, asked on the first). Seereferences/scrum-model.md. - Report: produce a sprint/velocity summary to chat (points committed vs done, carry-over, blocked issues). Do not write a report file.
- Append history
{ "skill": "linear-scrum", "action": "sync", … }.
Definition of Done (per run)
- Setup:
list_issueson the Project returns the pushed issues;meta.json#linearpopulated; a re-run creates no duplicates (verify by re-running Setup and confirming the issue count is unchanged). - Sync: the active cycle holds planned issues up to the velocity target and a report was produced.
- Scripts stay green:
cd linear-scrum/scripts && python3 -m unittest test_scripts.
What this skill does NOT do
- Doesn't write/estimate tasks (that's
prd-to-tasks). - Doesn't build the app or agent (
design-md-to-app/eve-agent). - Doesn't run human ceremonies (standup/retro) or generate ceremony artifacts.
- Doesn't create a Linear team per project — one team, many Projects.
- Doesn't bump
phase.
What ships with it: 6 files
40.3 KB alongside SKILL.md, 3 of them executable
references/
- contracts.md28.9 KB
- linear-mcp.md2.4 KB
- scrum-model.md2.4 KB
scripts/
- meta_linear.pyruns2.9 KB
- task_key.pyruns985 B
- test_scripts.pyruns2.7 KB