Brainforge Knowledge

2026-05-tickets-and-agents-training

8 min read

Training: Tickets-from-context + Scheduling Coding Agents

Owner: Davis Dunham Audience (target): Robert, Greg, Awaish, Demi at minimum; open to Amber, Jasmin, and anyone interested Length: 30 min + Q&A Format: Lunch-and-learn, recorded Status: Draft, pre-scheduling Origin: Slack thread with Uttam on 2026-05-06; Robert’s request in help-skills earlier the same day asking who is “an expert here on how to create project plans, tickets, and to schedule coding agents”.

Why this session exists

Two pain points keep showing up — surfaced verbatim by two different people on the same day (2026-05-06):

  1. Effective ticket creation from context, slotted into milestones. Greg, in a DM: “The top two things that can speed up my work are: (1) effective deck prep and (2) effectively creating tickets from context and slotting them into milestones.” Robert, in help-skills the same day: “who’s actually an expert here on how to create project plans, tickets, and to schedule coding agents? i find myself having to re-run multiple skills to get to an output that actually seems acceptable.” The new context-to-milestone-tickets orchestrator is named after Greg’s phrasing and built around Robert’s “stop re-running skills” frustration — same pain, two angles.
  2. Scheduling coding agents. Less acute as a tooling problem (mission-run is well-organized) and more a literacy problem — most folks don’t know the 5-block mission contract or when to pick keep-running (overnight gnhf) vs an in-session mission-run.

Brainforge’s standup deck for today/Monday (the platform standup) is the live example we’ll use during the demo.

Goals for the session

  • Everyone leaves knowing one front door for “context → tickets in the right milestone” (the new context-to-milestone-tickets orchestrator).
  • Everyone can articulate the Linear hierarchy (Initiative → Project → Milestone → Issue) and where context fits.
  • Everyone knows the 5-block mission contract for handing work to a coding agent and when to use which agent surface.
  • Everyone knows the canonical references so future skills/tools route to the same source of truth.

Agenda (30 min)

TimeTopicOwnerNotes
0:00–0:05Mental model: Linear hierarchy + where context fitsDavisShort whiteboard / slide
0:05–0:15Live demo: transcript → tickets → milestoneDavisUse Monday’s Platform Team Sync transcript (see below)
0:15–0:25Scheduling coding agents: mission-run, keep-running, fix-prDavisWalk through the 5-block contract
0:25–0:30Q&A + new-skill preview (context-to-milestone-tickets)AllAsk for breakage / friction reports

Recording goes to the team channel after; share path in the announcement.

Mental model (slide / whiteboard)

Initiative   →  Project          →  Milestone        →  Issue (Ticket)
(workstream)    (deliverable      (phase / batch       (0.5–2 day unit
                 group)             with a date)         of work)
  • Phases ≠ Milestones automatically. idea-to-tickets produces phases; you then have to slot them into Linear milestones. The new orchestrator closes that seam.
  • Every milestone needs ≥1 linked issue (I3 invariant in linear-orchestrator structure-hygiene).
  • Every project needs ≥1 initiative (I2 invariant). Don’t silently skip this; it’ll fail hygiene later.
  • Every active issue needs a project (I1 invariant).

Demo flow (live, ~10 min)

Transcript: knowledge/clients/unassigned/transcripts/2026-05-04_brainforge_platform_team_sync_42cf2bf3.md

Why this one: it’s the Monday Platform Team Sync (Mustafa, Uttam, Davis) that Uttam specifically suggested — everyone in the room has lived context, the work maps onto the Platform Linear team, and the standup naturally produces a mix of “ship this week” tickets and longer arcs. Perfect for showing milestone slotting against a real, familiar workstream rather than a contrived example.

Demo script:

  1. Show the old way. Open idea-to-tickets, run it on the transcript, watch it produce phases. Then open linear-orchestrator --mode project-update separately to wire milestones. Call out the friction explicitly: “this is the seam where Robert and I have been re-running skills.”
  2. Show the new way. Run context-to-milestone-tickets on the same transcript. Walk through:
    • Stage 0 — confirm team (Platform), project (existing platform initiative or propose), milestone mode.
    • Stage 1 — auto-classify as transcript → routes to transcript-to-linear-tickets playbook.
    • Stage 2 — resolve target: surface existing Platform milestones, propose slotting per item, flag anything that needs a new milestone with a target date.
    • Stage 3 — draft ticket table with milestone slotting baked in; show ai-assignable vs human-only labels picked automatically.
    • Stage 4 — single confirmation summary, then writes.
    • Stage 5 — offer mission-run handoff on the first ai-assignable ticket so the loop closes from “we said this in standup” to “an agent is working on it.”
  3. Show one ticket detail. Highlight the canonical description format (Context / Goal / Scope / Acceptance / Notes / Open Questions) — not optional, not negotiable.
  4. Highlight what gets caught: missing initiative, milestone with no linked issue, duplicate ticket. The orchestrator stops on these instead of writing junk.

Scheduling coding agents (~10 min)

One front door: mission-run (router). It picks the right child playbook based on surface.

SurfaceSkillUse when
Cursor IDE, in-sessioncursor-mission-runDay-to-day pair-programming with subagents
Codex (CLI/desktop)codex-mission-runCodex-assigned long sessions
OpenCode (TUI / opencode run)opencode-mission-runHeadless runs, repo-rooted opencode.jsonc
Overnight, unattendedkeep-running (gnhf)One-commit-per-iteration, multi-hour autonomous loops; npm run tools:gnhf -- "objective"
Existing PR → greenfix-pr”Get this PR to merge”
Recurring scheduleloop / scheduleCron-style or interval re-runs

The 5-block mission contract (paste at start, restate after compaction)

  1. Goal — one line: what “done” means (tests, CI, user-visible behavior).
  2. Branch / PR — human-findable id (no secrets).
  3. Scope — files / directories owned by this mission; out-of-bounds paths.
  4. Acceptance — exact commands (npm run lint, npm run types, targeted tests) and merge order if multiple agents touched the tree.
  5. Blockers — decisions that must not be re-litigated after compaction or handoff.

Common mistakes

  • Skipping the contract, then losing context after compaction.
  • Letting two subagents edit the same files without a worktree split.
  • Not running an integrator pass before merge.
  • Using keep-running when an in-session mission-run would be better (or vice-versa). Rule of thumb: human steering needed → in-session; truly fire-and-forget → gnhf.

The new skill: context-to-milestone-tickets

Path: .cursor/skills/context-to-milestone-tickets/SKILL.md

What it does: single front door from raw context (transcript, Slack thread, idea dump, plan doc, SOW excerpt) to Linear tickets that are already slotted into a project + milestone, with optional handoff to a coding agent. Composes existing skills; doesn’t reimplement them.

Stages:

  1. Resolve inputs (team, project, milestone target, mode).
  2. Classify input → route to the right underlying playbook.
  3. Resolve target (team → project → milestone, with hygiene checks).
  4. Draft tickets with milestone slotting and AI/human labels.
  5. Confirm + apply (one yes, then writes in dependency order).
  6. Optional handoff to mission-run / keep-running.

Not for:

  • Single Platform ticket → use linear-orchestrator --mode ship-platform.
  • Audit-only board cleanup → structure-hygiene.
  • GTM / marketing ops → gtm-orchestrator --mode tickets.
  • Quarterly planning → quarterly-planning.
  • Pre-baked engagement kickoffs → omni-zero-to-one-linear-setup / edge-to-activation-tickets.

Status: consolidation-review: pending — let the weekly skill-consolidation cron decide whether this folds back into linear-orchestrator as a new mode after we have feedback.

Canonical references (always route here, never copy)

TopicPath
Ticket format (Context / Goal / Scope / Acceptance / Notes / Open Questions)knowledge/standards/04-prompts/tickets/linear-ticket-generation-from-transcript.md
Idea-to-tickets SOP (PRD vs LWDD vs TDD)knowledge/standards/04-prompts/planning/idea-to-tickets-sop.md
AI vs human labelsknowledge/standards/03-knowledge/engineering/setup/linear-labels-ai-human.md
Linear MCP tool mapknowledge/standards/03-knowledge/engineering/setup/linear-mcp-tool-map.md
Linear MCP ticket standards.cursor/rules/linear-mcp-ticket-standards.mdc
Branch + PR conventions.cursor/rules/linear-github-branch.mdc, .cursor/rules/github-pr-description.mdc
Service taxonomy + cap-* proxies.cursor/skills/linear-orchestrator/references/taxonomy.md

Underlying skills (composed by context-to-milestone-tickets)

  • idea-to-tickets — Idea → Plan → Phases → Project → Tickets
  • transcript-to-linear-tickets — canonical transcript → tickets playbook
  • linear-orchestrator — modes: ship-platform, project-update, roadmap-to-structure, structure-hygiene, sow-alignment, status-sync, label-apply, label-audit
  • mission-run — surface router for coding agent missions
  • keep-running — overnight gnhf loops
  • fix-pr — drive an existing PR to merge

Where transcripts live (FAQ)

  • Yes — they’re in the platform repo, under knowledge/clients/{client}/transcripts/ and knowledge/clients/unassigned/transcripts/. Internal / non-client meetings live in knowledge/engineering/meeting/transcripts/.
  • Granola syncs them in via the sync-granola-to-vault skill (file naming: YYYY-MM-DD_<slug>_<granola-id>.md).
  • For ad-hoc engineering meetings, look under knowledge/engineering/meeting/transcripts/ first.

Open questions / follow-ups

  • Schedule the session — confirm 2–3 slot options with Robert / Greg / Awaish / Demi.
  • Recording: post in team channel after, link from this doc.
  • After 1 week of usage, decide whether to fold context-to-milestone-tickets into linear-orchestrator as a new mode (the consolidation-review: pending flag will surface it in the weekly skill-consolidation cron).
  • Track: how many real workflows end up needing the seam closed vs how many were one-skill jobs all along.

Test transcript (for me, before the session)

Primary pick: knowledge/clients/unassigned/transcripts/2026-05-04_brainforge_platform_team_sync_42cf2bf3.md

Why: it’s the Monday Platform Team Sync (Mustafa, Uttam, Davis) Uttam suggested. Everyone in the room has lived context, the team is Platform, and the standup naturally produces both “ship this week” tickets and longer arcs — clean test for milestone slotting on a familiar workstream.

Backups:

  • knowledge/clients/unassigned/transcripts/2026-04-22_bdr_dashboard_review_d6924c79.md — concrete dashboard changes, “by Friday” deadline, identifiable owners; tight mapping to a single milestone if the platform sync feels too sprawling on the day.
  • knowledge/clients/unassigned/transcripts/2026-05-06_brainforge_x_default_roadmap_regroup_76deab88.md — heavier roadmap session; better for showing the roadmap-to-structure route.
  • knowledge/clients/lmnt/transcripts/12_30_2025_january_planning.md — multi-milestone January planning; good for showing milestone inference.

Changelog

  • 2026-05-06 — Initial draft. Davis.

Graph View