How engineering teams use Plane with Codex and Claude Code

The specification in a Page, acceptance criteria on work items, and the scope of a Release already give engineering teams much of the context they need to plan, build, and ship.

Plane's MCP server connects ChatGPT and Claude to that context and lets them take actions allowed by the connected user's permissions. These five workflows show ChatGPT, Codex, and Claude Code using Plane records alongside repository tools when needed. The Inventory CSV import example connects planning, implementation, release notes, and scheduling, while a separate security audit shows how to check code against requirements.

• ChatGPT: Turn a specification in Plane Pages into reviewed implementation work and dependencies.
• Claude Code: Implement and test code against acceptance criteria stored in Plane work items.
• Claude Code: Check existing code and tests against the requirements and track gaps.
• Codex: Draft verified release notes from a Plane Release's approved scope.
• Codex: Schedule implementation work and review blocking dependencies in Timeline.

Use case 1: Map the build before the first commit

A CSV import specification might describe upload, parsing, validation, and confirmation, but the team still needs to decide which work items to create and what depends on what. The requirements for Retail Admin live in a Plane Page linked to the feature work.

Pull requirements from Plane Pages into ChatGPT

With Plane connected to ChatGPT, an engineering lead asks it to break down the existing Inventory CSV import requirements into implementation work and identify dependencies. There is no need to paste the specification or look up work item IDs.

The request covers upload and parsing, validation, import preview, confirmation, and testing. The preview must use validation results before it can tell users which records are safe to import.

Create modules and map work item dependencies

ChatGPT creates the Inventory CSV import module with 14 work items and links the preview to its blocking validation work. The lead then reviews the created records in Plane and corrects any scope or ownership details before implementation.

As implementation moves forward, the same module shows the 14 work items distributed across states. The module image is a later snapshot, not the moment immediately after creation.

The module keeps the agreed scope visible as individual work items move from Backlog and Todo through review and completion.

Use case 2: Bring acceptance criteria into the coding session

The Inventory CSV import module includes a work item to build the preview and confirmation interface. The feature must show parsed rows, explain invalid records, and let the user confirm or cancel before inventory changes are saved.

Those acceptance criteria matter: showing a CSV preview is not sufficient if invalid rows slip through or confirmation saves unintended changes.

Give Claude Code context from Plane work items

Marcus, an engineer, assigns the preview work item to Claude Code and mentions it in a comment, asking it to implement the interface and test invalid records. With Plane MCP connected, Claude Code can retrieve the work item context and inspect the relevant application code and tests.

The activity history captures the assignment and implementation request, then shows Claude Code reporting pull request #214, its test results, and a state change to In Review.

See implementation evidence in the Development panel

Claude Code implements the import preview, runs the tests, and opens PR #214 for review. The screenshot shows 18 of 18 tests passing. Passing tests provide evidence of the implementation, but do not replace code review or QA sign-off.

With GitHub integration configured, branches, commits, and pull requests that reference the work item identifier appear in the Development panel. Plane matches identifiers in branch names, PR titles or descriptions, and commit messages.

The reviewer can open the linked PR, compare it with the acceptance criteria, and request changes before merging. The work item stays In Review until the relevant review and verification are complete.

Use case 3: Find the gaps hiding behind passing tests

Code review and test execution do not always expose requirements that were never implemented or tested. An engineering team may need a separate coverage check before handing a feature to QA.

Take a role-restricted data export feature. Its acceptance criteria in Plane require exports to respect user permissions, reject unauthorized requests, and record successful exports for audit purposes. The feature has already been implemented, but the team wants to identify gaps before sign-off.

Audit work item acceptance criteria against the code

Claude Code retrieves the work item's acceptance criteria through Plane MCP and inspects the relevant authorization code, export endpoints, and tests through its repository tools.

The review should distinguish implemented behavior from test coverage. For example, an authorization check may exist on the page that starts an export, while the download endpoint needs its own permission check. A test that covers the happy path does not prove the unauthorized path is protected.

The agent can produce a criterion-by-criterion assessment with references to the code and tests it inspected.

Track confirmed gaps as work items in Plane

If the engineer confirms the missing permission check or test coverage, Claude Code can create the corresponding follow-up work items in Plane. An implementation fix and an additional negative test have different outcomes, so the engineer reviews the scope of each before creating it.

The investigation happens against the repository, but confirmed gaps return to Plane as work items that can be assigned, prioritized, and verified.

Use case 4: Make release notes match what's shipping

A Release Changelog should reflect work that has actually passed review and verification, not everything originally planned. Retail Admin v3.2 provides an example: its CSV import release covers upload and parsing, row-level validation, and preview and confirmation, with known limitations called out separately.

Build the draft from Plane Release scope

With Plane MCP connected, Codex can inspect the Release scope, its work items, and recorded verification evidence. The release owner confirms the changes approved for inclusion before asking Codex to draft the technical notes.

The draft describes confirmed behavior and leaves follow-up work in Known limitations. For this release, empty-file handling and malformed-row testing are called out as follow-ups rather than silently treated as shipped.

This is a later stage than the PR #214 screenshot, which still shows review pending. Release notes should only claim the implementation shipped after the necessary review and verification.

Save the approved notes in the Changelog

Codex waits for the release owner's approval, then saves the verified notes to the Release Changelog through Plane MCP. Readers can review them next to the Release's Overview and Scope.

Use case 5: Schedule implementation dependencies in Timeline

After the CSV import work is broken down, the engineering lead needs dates that respect the dependencies. A task list alone cannot show whether dependent work has been scheduled in the right order.

Set dates and review dependencies with Codex

The lead asks Codex, connected to Plane, to schedule the relevant work and verify its dependencies. Inventory validation needs to be ready before the import preview can rely on its results.

Codex can set start and due dates and record blocking relationships through Plane MCP. The lead checks the dates and links in Plane rather than relying only on Codex's summary.

Inspect dependencies in Plane Timeline

The lead opens Timeline to inspect four relevant work items from the 14-item Inventory CSV import module. A connector shows that the preview work is blocked by inventory validation.

The module count remains 14, but this Timeline screenshot focuses on the four work items shown. The lead can review dates and durations, then adjust the schedule if a prerequisite slips.

This gives the team a visible implementation sequence and a practical way to check dependencies as dates change.

Connect Plane to your AI tools

Start with the tool that fits the task. ChatGPT can organize requirements in Plane; Claude Code can implement against work item criteria; Codex can inspect code, prepare release notes, and help schedule dependencies. Repository inspection and test execution depend on the coding tool's own setup.

In ChatGPT, turn on Developer mode in Settings (where available), add a connection named Plane using https://mcp.plane.so/http/mcp, and authorize it with your Plane account. For Business, Enterprise, or Edu workspaces, an admin may need to enable access.

In Claude, add a custom connector under Settings → Connectors using https://mcp.plane.so/http/mcp, sign in to Plane, and enable the connector in your conversation. On Claude Team or Enterprise, an organization Owner may need to add the connector first. Follow the Plane MCP server setup guide for the latest client-specific instructions.

For Codex:

codex mcp add plane --url https://mcp.plane.so/http/mcp
codex mcp login plane

For Claude Code:

claude mcp add --transport http plane https://mcp.plane.so/http/mcp

Run /mcp in Claude Code to authenticate and check the connection. Plane MCP calls Plane's API directly, so it doesn't consume Plane AI credits. Model usage belongs to your AI tool.

Bring your engineering workflows into Plane, from planning implementation work to tracking code changes and preparing releases. Get started with Plane for free or connect your AI tools to your existing Plane workflows.