Using coding agents with Windshift
Let coding agents read workspace context, turn plans into structured work, and keep the record current through the CLI or MCP.
A coding agent can produce a plan in chat. Turning that plan into work still takes effort: someone must create backlog items, attach the spec, and keep each status current.
Windshift lets the agent do that work itself. It can read workspace pages, create and update items, add comments, follow workflow transitions, and link documentation to the work it describes.
Agents can use either interface:
Read the workspace before acting
An agent needs to know the workspace key, item types, statuses, transitions, and documentation conventions. `ws init` writes those details to `WINDSHIFT.md` in the project root, where editor agents can read them before acting.
The file also points agents to workspace pages. These pages hold specs, design notes, decisions, runbooks, and postmortems. Reading them first helps the agent use the team's language and avoid duplicate documentation.
Use MCP for Windshift and the CLI for the repository
Enable the optional MCP server with the `--mcp` flag or `MCP_ENABLED=true`, then connect an MCP client to the `/mcp` endpoint.
```bash
Convert the plan into work items
For larger changes, ask the agent to create a parent item for the outcome and child items for the work. The exact type IDs come from `WINDSHIFT.md` or `ws item-type ls`.
```bash
Preserve the reasoning behind the plan
A description can summarize the outcome. A linked page can hold the goals, constraints, source material, decisions, rollout notes, and open questions.
```bash
Update the work item during implementation
The agent can update Windshift as the implementation moves:
```bash
Give the agent only the access it needs
Give an agent only the access its task requires. Use a dedicated account with limited workspace roles and scoped tokens. The MCP server requires `mcp:access`, but all underlying permissions still apply.
People retain the product decisions and review the result. The agent handles the repeatable coordination: read the source material, structure the work, update the record, and connect each item to the context behind it.