Linear + Cursor + Codex Workflow Integration

The clearest pattern across official documentation:

• Linear = System of record for work (planning, prioritization, status)
• Cursor / Codex = Systems of execution for code (interactive & agent-driven)
• GitHub / GitLab = Source of truth for code review and merge state

This pattern appears consistently in Linear's workflow model, GitHub automation, Cursor's Linear integration, and Codex's guidance to treat agents as configurable teammates rather than one-off chatbots.

Core Principle: Separate Concerns

Don't make Cursor or Codex your task tracker. Keep these responsibilities separate:

• Planning, prioritization, triage, cycle commitments, status → Linear
• One-issue-at-a-time implementation with context and tests → Cursor / Codex
• Code review and merge verification → GitHub / GitLab

Linear explicitly supports team workflows (Triage, status automation, cycles, GitHub linking). Codex recommends prompts with goal, context, constraints, and "done when," plus reusable repo instructions in AGENTS.md. Cursor supports persistent Rules, Skills, and Hooks.

The Default Workflow

Follow this pattern as your baseline:

1. Capture and Prioritize in Linear

Send bugs, support requests, and ideas into Linear Triage from Slack, Sentry, or support tools. Use a rotating owner to sort, dedupe, and accept/decline items before they enter the team workflow.

Why Linear for this?

• Single source of truth for what needs doing
• Triage workflow designed exactly for inbox management
• Prevents duplicates and out-of-scope work
• Captures context from multiple input channels

2. Commit Work in Cycles or Projects

• Projects = Larger outcomes (new feature, redesign, infrastructure)
• Cycles = Short time-boxed execution (1-2 week sprints)

Linear's docs describe cycles as time-boxed work periods separate from releases, with automatic upcoming cycle creation and cycle graphs for scope/progress.

3. Make Each Issue Implementation-Ready

Before handing work to an AI coding tool, write the issue with:

• Scope: What's the boundary of this work?
• Acceptance criteria: How do we know it's done?
• Links: Relevant files, docs, related issues
• Constraints: Performance, backwards compatibility, security requirements

This matches Codex's recommended prompt structure: goal, context, constraints, and done-when.

4. Execute in Cursor or Codex

Cursor = Editor-centric interactive work and background agents
Codex = IDE, CLI, or cloud execution with explicit agent workflows

Both support:

• Understanding the codebase (context)
• Building features with tests
• Fixing bugs with verification
• Reviewing changes before merge

5. Sync Progress Automatically via GitHub

Let branch names, PR titles/descriptions, commit messages, and review state update the Linear issue automatically. Don't manually move cards around.

Linear's GitHub automation supports:

• PR linking and commit linking
• Magic words (Fixes, Closes)
• Issue status automation
• Review state syncing

6. Require Verification Before "Done"

"Done" means tests + review, not just "agent produced code."

• Codex: Create/update tests, run checks, confirm behavior, review diffs
• Cursor: Use Bugbot for PR diff analysis
• Both: "AI writes, human reviews/merges"

Workflow Shapes by Team Size

1. Solo Developer / Founder

Use Linear lightly, Cursor heavily.

Keep one Linear team with simple statuses (maybe no cycles at first). Track bugs and features in Triage → Todo. Pull one issue at a time into Cursor, ask for a plan first on anything nontrivial, then implement, test, and open a PR.

Good setup:

• Linear statuses: Backlog, Todo, In Progress, In Review, Done
• Cursor: Project rules for coding conventions
• GitHub: Automatic issue linking / status updates
• Cursor prompt template: "Goal / relevant files / constraints / done when"

Workflow:

Linear (plan) → Cursor (code) → GitHub (review + merge)

2. Small Startup Team (3-10 engineers)

Use Linear for planning, Cursor for interactive coding, Codex for repeatable CLI tasks or larger agentic jobs.

Standardize agent behavior with AGENTS.md and config files (Codex) or Rules/Skills/Hooks (Cursor) for persistent instructions.

Good setup:

• Linear Triage fed by Slack, Sentry, customer channels
• 1-2 week Linear cycles
• Cursor Rules or repo instructions for style, testing, security
• Codex AGENTS.md with build/test/lint commands and "definition of done"
• PR review in GitHub; Bugbot or Codex review before merge

Workflow:

Slack/Sentry → Linear Triage → Linear Cycles
                  ↓
         Cursor (interactive)
         Codex (background agents)
                  ↓
            GitHub PR review
                  ↓
         Linear status updates (automatic)

3. Product + Engineering Org (50+ people)

Use Linear as the cross-functional hub, AI tools as specialist workers.

Linear supports projects, initiatives, milestones, updates, and integrations across Slack, Notion, Sentry, GitHub, and more. As of February 2026, Linear expanded its MCP server for initiatives, project milestones, and updates so product work can be updated from Cursor and Claude.

Good setup:

• PM/spec in Linear project with product context
• Engineering issues decomposed into sub-issues
• AI coding agent works issue-by-issue with tight scope
• GitHub state sync updates Linear automatically
• PMs stay in Linear; engineers stay mostly in editor/terminal

Workflow:

Product (Linear) ← → Engineering (Linear sub-issues)
                       ↓
              Cursor / Codex agents
                       ↓
              GitHub PR → Linear auto-sync

4. Support / Bug Triage Workflow

One of the best AI-assisted patterns.

Send incoming bug reports to Linear Triage from Slack/Sentry/monitoring. Dedupe and prioritize there, then either assign to humans or trigger a Cursor background agent from the issue.

Cursor's Linear integration supports mentioning @Cursor in a comment to assign a new agent. Cursor's blog describes launching background agents directly from Linear issues.

Clean bug workflow:

1. Error report lands in Linear Triage
2. Triage owner normalizes repro steps and severity
3. @Cursor or Codex gets a tightly scoped implementation task
4. PR is opened and reviewed
5. Linear status advances automatically from code activity

Where Each Tool Fits Best

Linear

Best for: Prioritization, workflow state, team coordination, analytics on work

• Team-specific statuses
• Triage for inbox management
• Cycles for time-boxed work
• Projects for larger outcomes
• Insights for team metrics
• GitHub/Slack integrations

Cursor

Best for: Interactive implementation in the editor, background agents, repo-specific rules

• Plan Mode (for understanding codebases before coding)
• Persistent Rules for coding standards
• Hooks for workflows
• Skills for multi-file operations
• Background agents for parallel work
• Built-in Linear integration

Codex

Best for: Explicit agent workflows across IDE, CLI, and cloud with standardized prompts

• Reusable prompts with goal/context/constraints
• AGENTS.md for team standards
• Configuration management
• MCP connections for integrations
• Testing and review loops
• Automations across surfaces (IDE, terminal, cloud)

Recommendations to Actually Follow

Use these as defaults unless you have a strong reason not to:

1. Don't Let AI Tools Invent Backlog State

AI should update code and maybe draft comments, but Linear owns prioritization and status policy. Never let an agent decide what's important or create new work items without human review.

2. Always Plan First for Medium/Large Tasks

• Cursor has Plan Mode
• Codex recommends Plan mode for difficult tasks
• Spend 5-10 minutes understanding scope before implementation

3. Write Persistent Repo Rules Once

• Cursor Rules / Hooks / Skills
• Codex AGENTS.md
• This is the highest-leverage setup step. Write your standards once, reuse forever.

4. Drive Status from Git Activity When Possible

Use branch names, PR titles, commit messages, and review state to update Linear automatically. Reduces manual project-manager busywork.

Example magic words:

• Fixes #123 (links and closes)
• Closes RFX-40 (Linear integration)
• PR title includes issue key (automatic linking)

5. Make "Done" Mean Tests + Review, Not Just Code

"Done" = implementation + tests + PR review + merge, not just "agent produced code."

6. Start with Narrow Permissions

• Codex: Keep approval/sandboxing tight by default, loosen only for trusted repos
• Cursor: Document approval controls for terminal execution
• GitHub: Require review before merge

The Best-Integrated Workflow

Linear for deciding. Cursor/Codex for doing. GitHub/GitLab for verifying and merging.

Teams are happiest when they keep those responsibilities separate instead of trying to make one tool do everything.

Example Flow for a Feature

1. Product writes spec in Linear project
   ↓
2. Engineering breaks down into sub-issues
   ↓
3. Issue tagged with "ready for development" and assigned to dev/Cursor
   ↓
4. Dev opens Cursor, selects the issue, runs Cursor Plan to understand scope
   ↓
5. Cursor implements with tests, opens draft PR
   ↓
6. Dev reviews, requests changes, or approves
   ↓
7. PR merged → GitHub → Linear status auto-updates to Done
   ↓
8. Issue closes, metrics updated in Linear

Setup Checklist

• Linear workspace with Triage, cycles, and GitHub integration
• Cursor Rules (or repo .cursorrules file) with coding standards
• Codex AGENTS.md if using background agents
• GitHub branch protection with required reviews
• PR template linking to Linear issues
• Linear automation: PR labels → issue status
• Team agreement: What "implementation-ready" means for your issues

Related Reading

• Linear: Workflow docs and GitHub integration
• Cursor: Rules documentation and Background agents
• Codex: Workflow docs and AGENTS.md pattern
• GitHub: PR automation

Takeaway: The best-integrated workflow treats Linear, AI tools, and GitHub as specialists in different domains, not as interchangeable alternatives. Each tool does its job better when it stays in its lane.