agentsclimarketplace

Linear scrum

Skill lukedj78/dev-flow/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

Install
npx -y skills add lukedj78/dev-flow --skill linear-scrum

Assembled 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_teams before any write. For the headless server loop use the API-key path in docs/loop-engineering.md instead — this skill is the interactive counterpart.
  • .workflow/meta.json exists (dev-flow project). If not, tell the user and stop.
  • .workflow/tasks.md exists for Setup mode (run prd-to-tasks first otherwise). Coupled format: scripts/task_key.py derives its dedup key from the - [ ] **<Title>** — <body> line shape produced by prd-to-tasks, splitting on the em-dash (—) to isolate the title — if tasks.md was 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#linear and tasks.md present → Setup mode.
  • A Linear Project already exists for this project but meta.json#linear is absent/partial → Adopt mode.
  • meta.json#linear present → Sync mode.

Do one logical operation per invocation, then stop. Every mode is idempotent.

Setup mode (new project)

  1. list_teams → resolve the team (single team today: Lucadigerlando). One dev-flow project = one Linear Project under that team, never a new team.
  2. Ensure scrum config on the team:
    • Estimates — verified working: save_issue accepts a Fibonacci estimate (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 via save_issue's cycle field.
  3. Create/link the Linear Project (save_project); capture its id + url.
  4. 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_labels and map the conceptual buckets — web / agent / scaffold — onto the workspace's own labels (e.g. this workspace uses frontend / agent-eve / setup, not area:*). Derive web-vs-agent from meta.json#stack + the task's *(addressed by …)* tag; record the resolved mapping in meta.json#scrum.labels. Create a label only if no reasonable match exists.
    • milestone: map epics/milestones via save_milestone when tasks.md groups by epic.
    • record each task_key(line) → issue identifier for the next step.
  5. 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.
  6. Persist state:
    python3 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", ...}'
    
    Then append a history entry via dev-flow/scripts/update_meta.py: { "skill": "linear-scrum", "action": "setup", "ran_at": "<ISO8601>" } (no phase bump).

Adopt mode (existing project already partly in Linear)

  1. Discover the existing Project and its issues (list_projects, list_issues).
  2. Match issues to tasks.md lines by title (task_key) and backfill issue_map without creating anything (meta_linear.py record-issues).
  3. Fill any missing scrum config (meta_linear.py ensure-scrum), then upsert-linear with the discovered project id/url.
  4. Append history { "skill": "linear-scrum", "action": "adopt", … }.

Sync mode (ongoing, horizontal)

  • Push new tasks: for each tasks.md line whose task_key is not in issue_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/Todo into the active cycle up to the velocity target (meta.json#scrum.velocity_target; learned from past cycles, asked on the first). See references/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_issues on the Project returns the pushed issues; meta.json#linear populated; 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/

scripts/

Keep looking

Skills are one crate of 611,884. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.