Humans own the design.
Intent, functional spec, architecture, risk, inline review, approval, and the merge decision.
Solutions
Agentic engineering
Agentic engineering is the discipline of building software with coding agents without giving up the engineering. You own the functional spec, the architecture, and the design — written down, reviewed, approved. Agents write the code to it. Windy is the workspace that runs it end to end.
Works with your agents
Claude CodeCursorCodexOpenCodeMCP-aware coding agents
Agentic engineering starts with an owned design, not a longer prompt.
Vibe coding asks the agent to infer the system from the current instruction and whatever context is attached — and hands you back code nobody specified. Agentic engineering keeps the two jobs separate: the functional spec, the architecture, and the design are yours, reviewed and approved; the implementation is the agent's. Windy gives both sides one workspace — a knowledge base plus Work items that move from a proposal to review, a task list, an execution, and a reviewed changeset — a workflow that survives across sessions and tools.
Windy is not another coding agent. It is the workspace for agentic engineering — where the design is owned and reviewed, and every change is proposed, executed, and merged in the open.
The shift
The old workflow was prompt, patch, forget.
In prompt-driven AI coding, each run often starts cold. The developer explains the task, pastes context, gets a patch, reviews the result, and then much of the reasoning disappears into chat history. The design was never written down, so nothing can be reviewed as a whole and nothing can be safely changed later. That can work for small edits, but it does not scale to architecture-sensitive work, multi-session tasks, or multiple agents.
| Approach | Starts from | Produces | Main weakness |
|---|---|---|---|
| Vibe coding | The current prompt and selected context | A patch or answer | The design is never owned; context disappears after the run |
| Agentic engineering | An approved spec, architecture, and design in a Work item | A maintainable system, reviewed executions, merged changesets | Requires a maintained workspace |
Agentic engineering is not just using AI more often. It is changing where the design lives — in a reviewed workspace, not a chat log.
The workflow
Agentic engineering is the discipline. Agent-Native Development is the workflow that runs it.
A discipline needs a loop you can actually run. Windy runs the Agent-Native Development (AND) workflow: the agent never starts from a blank prompt — it starts from the current knowledge base and a proposal you reviewed. Humans own the intent, the architecture, and the design; agents do the focused implementation; every change is proposed, reviewed, executed, and merged. The full treatment lives on How Windy works.
01
Intent
Create a Work item, pick a Work Type, and state what you want built.
02
Proposal
The agent drafts the implementation and verification specs from the knowledge base — the design, in writing.
03
Review
You own this gate: comment inline, push back, and the agent revises until the design is one you approve.
04
Task List
The approved proposal becomes an ordered task list with per-task subagent prompts.
05
Execution
A coding agent writes the code and records status, logs, and the commit SHA for each task.
06
Changeset & merge
Knowledge-base edits stage into a reviewed changeset, then merge atomically alongside the code.
The workflow makes agent work continuous and reviewable instead of episodic and opaque.
Read the full workflow → How Windy works
The workspace
One place holds the design and the work.
A repository is necessary, but it is not enough. Agentic engineering needs a workspace that explains what the system should do, what work is proposed, what ran, and what merged — all attached to the Work item it belongs to.
- Knowledge base — the project's authoritative specs, architecture, diagrams, and decisions that agents read before they build.
- Work items & Work Types — each piece of work is a typed Work item — Feature, Bug Fix, Refactoring — carrying intent, attachments, and copyable instructions.
- Proposal & verification specs — the agent drafts an implementation spec and a verification spec, scoped to the Work item; you approve them before any code is written.
- Inline review — humans and agents comment inline on proposals and changesets; the agent can answer, revise, and re-submit.
- Task Lists — an approved proposal becomes an ordered task list, each task with its own objective and ready-to-run subagent prompt.
- Executions — every run is recorded with per-task status, logs, and the commit SHA it produced — traceable back to the code.
- Changesets — knowledge-base edits stage into a reviewed, atomically-merged changeset instead of publishing straight away.
The knowledge base is the long-term source of truth; Work items carry each change through proposal, execution, and merge.
Roles
Agentic engineering does not mean developer-optional.
Coding agents can draft proposals, run task lists, implement code, and record executions — but the functional spec, the architecture, the tradeoffs, the inline review, and the merge stay human-owned. Agentic engineering works best when the human role becomes clearer, not smaller: you move up the stack, from typing the code to owning the system.
Agents write the code.
Draft proposals, run task lists, implement code and tests, and record executions.
The workspace keeps continuity.
Proposals, reviews, executions, and merged changesets stay attached to the Work item across people, agents, and sessions.
The developer becomes the architect and reviewer, not the person rewriting the same context every run.
What this looks like in practice.
A team wants to add organization-level audit logs to a SaaS app.
Vibe-coded workflow
The developer writes a long prompt, points the agent at a few files, gets a patch, then repeats context for the API, UI, docs, and tests. The design lives in chat history, nothing is reviewed as a whole, and six months later nobody can say why retention works the way it does.
Agentic engineering with Windy
- You create a Work item — a Feature — for organization-level audit logs, and copy its author-proposal prompt to your agent.
- The agent reads the knowledge base and drafts a proposal spec: events, actors, permissions, retention, filtering, export, and acceptance criteria.
- It also drafts a verification spec describing how each behavior will be proven.
- You own this gate. You review the proposal inline, push back on retention, and the agent revises until you mark the design ready.
- Approving the proposal opens the knowledge-base changeset gate and turns the approved design into an ordered task list — schema, capture, API, UI, tests, docs, rollout.
- An execution runs the task list; the agent writes the code and each task records status, logs, and the commit SHA it produced.
- The knowledge-base changeset is reviewed and merged atomically, so docs and code land together.
- The Work item keeps the whole record — design, review, execution, and merged changeset — ready for the next change.
The work is no longer a series of disconnected prompts. It is an engineered change agents did the typing for — and it leaves a record.
Infrastructure
Coding agents need a workspace between prompts and the repo.
Engineering with agents takes more than a model and a repository. It takes a way for agents to read the knowledge base, work through a design you approved, record execution, and merge the result back — over one MCP endpoint.
- Coding agentsClaude Code, Cursor, Codex, OpenCode, and future tools.
- Agent interfacethe per-(user, project) MCP endpoint that lets agents read context and take actions.
- Windy workspaceknowledge base, Work items, proposals, task lists, executions, and changesets that agents read and write over MCP, running the Agent-Native Development workflow.
- Repository and systemscode, tests, deployments, logs, tickets, and product infrastructure.
The workspace is what lets agents work on the project — its design, plan, and history — instead of only on the prompt.
Windy
Windy is the workspace for agentic engineering.
Windy gives each project one workspace: a knowledge base for the durable, human-owned design, and Work items that carry each change from proposal to review to task list to execution to a reviewed changeset — the Agent-Native Development workflow, end to end. Humans steer and review in the web app. Coding agents read and write over a per-(user, project) MCP endpoint, so every change is attributed to a person.
Knowledge base — the durable design.
Requirements, specs, architecture notes, diagrams, contracts, schemas, and decisions — the authoritative source of truth agents read before they build.
Work items — the workflow.
Intent to merge: proposal and verification specs, inline review, task lists, executions with per-task commit SHAs, and reviewed changesets.
Your agents still write the code. Windy makes sure the system stays yours.
Best-fit use cases
Architecture-sensitive feature work
permissions, billing, authentication, workflows, integrations, and state machines.
Large refactors and migrations
work that needs sequencing, dependencies, and acceptance criteria.
Multi-agent teams
projects using Claude Code, Cursor, Codex, OpenCode, or future MCP-aware agents together.
Spec-driven teams
teams that want coding agents to build from an approved design instead of one-off prompts.
Long-running projects
work that spans multiple sessions, branches, reviews, and agents.
Teams that want docs to stay current
projects where every change merges the knowledge base alongside the code.
FAQ
Questions, answered.
Agentic engineering is the discipline of building software with coding agents while keeping the engineering human-owned: you own the functional spec, the architecture, and the design — written down, reviewed, approved — and the agent writes the code to it. You keep the agent's speed, and the system it produces stays maintainable and yours.
Vibe coding hands the agent the design and the code at once: you prompt, you get a diff, and the design is never written down. Agentic engineering separates them — the design is approved first, the agent implements against it, and the change lands through a reviewed changeset.
Windy runs Agent-Native Development (AND) — the workflow that delivers agentic engineering. A Work item carries intent to a proposal (implementation + verification specs), then inline review, a task list, an execution with per-task commits, and a reviewed changeset merged back into the knowledge base. See how Windy works at /how-it-works/.
No. Humans still own product intent, the functional spec, architecture, risk, review, and release decisions. Agents draft proposals and execute focused work from that approved design. The role moves up the stack, it does not disappear.
Every agent reads the same knowledge base and works through the same proposals and changesets, so they build from one reviewed source of truth instead of a private, drifting context.
Windy is the workspace for agentic engineering: a knowledge base plus Work items that move from proposal to review to task list to execution to a reviewed changeset, exposed to coding agents over a per-(user, project) MCP endpoint.
Yes. Windy is agent-agnostic — Claude Code, Cursor, Codex, OpenCode, and any MCP-aware agent connect to the same workspace, each on their own attributed endpoint.
Related
Keep exploring.
Your agents still write the code. Windy keeps the system yours.
Start with one project, connect your agent over MCP, and build from an approved design instead of a one-off prompt.
windylogic.ai