Design context is scattered.
Specs, diagrams, tickets, and decisions live in different places.
Solutions
Memory for Claude Code
Claude Code can write and modify code quickly. Windy gives it the project memory it needs first: specs, architecture, diagrams, decisions, plans, tasks, and execution history served over project-scoped MCP.Works with Claude Code and other MCP-aware coding agents.
Claude Code writes the code. Windy gives it the project memory.
Claude Code is a strong coding agent, but it still depends on the context it can see. If the design lives across files, chats, tickets, diagrams, and decisions in someone’s head, each run starts from partial context. Windy gives Claude Code one project-scoped source of truth to read before it edits code — and to update as behavior changes.
Windy is not a replacement for Claude Code. It is the memory layer Claude Code builds from.
The problem
Powerful coding agents still start from the context they are given.
A coding agent can reason over code, follow instructions, and produce large changes. But it does not automatically know the current product intent, architecture decisions, migration plan, or hidden constraints of your project. When that context is missing, the agent has to infer it.
Every run rehydrates context manually.
You repeat the same background in prompts or local project files.
Architecture can be guessed.
If the intended design is not available, the agent fills the gap.
Plans disappear into conversation history.
Large tasks get decomposed, but the task sequence is hard to resume and review.
Docs and code drift apart.
After implementation, the next run may read old or incomplete context.
Claude Code becomes more useful when it can start from the project’s actual source of truth.
Project memory
Put the design, plan, and execution record where Claude Code can reach it.
Windy stores the project artifacts Claude Code needs to build safely. Humans can review and edit them in the web app. Claude Code can read and write them over MCP.
- Specs and requirements — what the system should do and how success is checked.
- Architecture notes — components, boundaries, constraints, dependencies, and ownership.
- Diagrams — system maps, workflows, data relationships, state machines, and cloud architecture.
- Contracts and schemas — APIs, events, database models, JSON, YAML, and interface definitions.
- Decision records — tradeoffs, rejected options, and the reason behind current design choices.
- Plans and tasks — ordered work with objectives, dependencies, acceptance criteria, and agent prompts.
- Execution history — what ran, what changed, what passed, and what still needs review.
The goal is not more context for its own sake. The goal is the right context before Claude Code writes code.
Workflow
Design first. Then let Claude Code build from the design.
Windy turns Claude Code sessions into a repeatable design-first loop.
01
Capture the design in Windy.
Store specs, architecture, diagrams, decisions, constraints, and requirements.
02
Create a plan for large work.
Break big changes into ordered tasks with objectives, dependencies, acceptance criteria, and prompts.
03
Let Claude Code read over MCP.
Claude Code uses the project memory before editing code.
04
Build and review.
You review the implementation against the same source of truth Claude Code used.
05
Update the memory.
As behavior changes, docs, plans, and execution history stay aligned with the code.
The next Claude Code run starts from the updated project memory, not the same cold start.
Plans
Turn large Claude Code work into reviewable tasks.
Some changes are too cross-cutting for a single instruction: billing migrations, authentication changes, schema refactors, infrastructure updates, or multi-step feature launches. Windy Plans turn those changes into ordered tasks Claude Code can execute one at a time.
- Objective — what this task should accomplish.
- Deliverables — what files, behavior, docs, or tests should change.
- Dependencies — what must happen before this task.
- Acceptance criteria — how the result will be reviewed.
- Subagent prompt — the ready-to-run instruction for the coding agent.
- Execution log — what happened during the run.
Windy Plans make Claude Code work easier to steer, pause, resume, and review.
What this looks like in practice.
You want Claude Code to add SSO to a SaaS app.
Without Windy
You write a long prompt and try to explain organizations, users, roles, identity providers, callback URLs, session handling, domain verification, migration concerns, and tests in one shot.
With Windy
- The authentication architecture note explains the current login model.
- The SSO spec defines supported providers, domain rules, session behavior, and failure states.
- The diagrams show login, callback, and organization-linking flows.
- The plan breaks the work into data model, backend, UI, tests, and docs tasks.
- Claude Code reads the relevant docs and task over MCP before editing code.
- Execution history records what changed and what remains.
- Docs and plans are updated as the implementation evolves.
Claude Code is no longer reconstructing the identity model from a single prompt. It is building from the project memory.
Setup
Give Claude Code a project-scoped MCP endpoint.
Windy projects expose a scoped MCP endpoint that your coding agent can use to read and write the project’s source of truth. The setup flow should be simple and explicit: create a project, connect the endpoint, then tell Claude Code to use Windy as project memory.
01
Create or open a Windy project.
Add the specs, architecture notes, diagrams, or plans Claude Code should use.
02
Copy the project's MCP endpoint.
Access is scoped to that project and can be revoked.
03
Connect Claude Code.
Add the endpoint to your Claude Code MCP setup.
04
Tell Claude Code how to use Windy.
Add a project instruction such as the one below.
Project instruction
Before editing code, read the relevant Windy Docs and current Windy Plan over
MCP. Use them as the source of truth for architecture, constraints, acceptance
criteria, and task order. If implementation changes behavior, update the related
Windy docs or execution notes.Control
More agent memory should mean more control, not less.
Windy does not replace review. It gives Claude Code better context and gives humans a clearer yardstick for review. The source of truth is visible, editable, and project-scoped, so developers can inspect what the agent is building from.
- Project-scoped access — Claude Code sees the connected project's memory.
- Revocable endpoint — access can be removed when needed.
- Human-readable docs — the same source of truth is visible in the web app.
- Reviewable plans — large work is decomposed into tasks and acceptance criteria.
- Execution history — previous agent runs leave a record.
Windy keeps the design in a place humans can own while giving Claude Code the context it needs.
Best-fit use cases
When Windy helps most with Claude Code.
Feature work with hidden rules
billing, permissions, authentication, onboarding, integrations, and workflows.
Architecture-sensitive changes
service boundaries, API contracts, data model changes, and event flows.
Large refactors
migrations that need sequencing, acceptance criteria, and progress tracking.
Multi-session work
tasks that span more than one Claude Code run.
Team workflows
when more than one developer or agent needs the same source of truth.
Documentation that must stay current
systems where future agents need to understand why the code is shaped the way it is.
FAQ
Questions, answered.
No. Claude Code writes and modifies code. Windy gives Claude Code a shared project memory to read and update over MCP.
Claude Code can only build from the context it can see. Windy gives it durable access to specs, architecture, diagrams, decisions, plans, and execution history.
Yes. CLAUDE.md is useful, but Windy is a project-scoped source of truth with docs, diagrams, plans, tasks, and execution history that agents can read and write over MCP.
The intended workflow is read/write: Claude Code can read the current source of truth and update docs, plans, or execution notes when behavior changes, with humans reviewing the result.
Yes. Windy is designed as a shared memory layer for MCP-aware coding agents, not a Claude-only memory.
Start with the spec, architecture notes, diagrams, constraints, acceptance criteria, and current plan for the work Claude Code should perform.
Related
Keep exploring.
Claude Code writes the code. Windy gives it the project memory.
Create a project, connect the MCP endpoint, and let Claude Code build from your source of truth instead of a cold start.
windylogic.ai