VGV Wingspan: An Open-Source Agentic Engineering Workflow for Claude Code

Handing a complex feature to an AI coding agent is the easy part. Getting the result back in a state you can actually ship is where things get difficult.

The agent wrote the code, but did it follow your architecture conventions? Did it catch the edge cases? Did it even start from a well-formed plan?

These are questions the team at Very Good Ventures has been wrestling with as it builds with Claude Code every day.

AI agents are powerful, but without structured workflow guardrails, the output drifts. The architecture gets inconsistent. Tests get skipped. Reviews happen too late to matter.

Wingspan is the answer to that gap. It is an open-source agentic engineering workflow that structures every AI-assisted coding session into four deliberate phases: brainstorm, plan, build, and review.

Instead of hoping the agent produces something shippable, Wingspan makes sure it follows a disciplined software development lifecycle from the first prompt to the final commit.

The project is releasing today in alpha, version 0.0.1. It is open source, built for Claude Code first, and it encodes the engineering practices the consultancy uses internally every day.

From Structure to Slash Commands: The Four Phases

A traditional software development lifecycle has well-defined stages: requirements, design, implementation, testing, and review.

When AI agents enter the picture, those stages tend to collapse into a single "just generate the code" step. The planning disappears. The review becomes an afterthought.

An agentic SDLC restores that structure. It treats the AI agent not as a replacement for the engineering process, but as a participant within it.

Each phase of the lifecycle has a clear purpose, clear inputs, and clear outputs. The agent operates within those boundaries rather than inventing its own.

This is closely related to what some teams call spec-driven development: defining clear specifications before the agent writes a single line of code.

• Structure keeps architecture consistent instead of accidental
• Planning prevents the agent from inventing its own path
• Review catches deviations before they reach production
• Guardrails make agent output reviewable and shippable

Wingspan operationalizes that principle by making each phase a concrete step the agent must complete, invoked as a Claude Code slash command.

The brainstorm phase is where you and the agent explore the problem space together. Before any code is written, the command helps surface requirements, identify edge cases, and clarify scope.

• /brainstorm — Explore the problem space and surface requirements before any code is written
• /plan — Produce a structured plan covering architecture, file structure, dependencies, and a sequenced task list
• /build — Execute the implementation, following the plan and respecting project conventions
• /review — Evaluate the result against the plan, flag deviations, and verify test coverage

The agent asks questions, proposes approaches, and documents the constraints that will guide every subsequent phase.

Once the problem is well understood, the plan phase produces a structured implementation plan. This is the spec-driven development step.

The agent generates a concrete plan covering architecture decisions, file structure, dependencies, and a sequenced list of tasks. Nothing gets built until the plan is reviewed and confirmed.

With a plan in hand, the build phase executes the implementation. The agent writes code that follows the plan and adheres to project conventions.

After the build is complete, the review phase evaluates the result. The agent checks the implementation against the original plan and flags deviations.

The review phase can loop back to brainstorm if significant gaps are found, creating an iterative cycle.

Built for Claude Code, Designed for Flutter

Claude Code was chosen as Wingspan's first platform because of its native support for skills and slash commands, its strong reasoning capabilities, and its ability to operate as an agentic coding partner.

Support for additional platforms is on the roadmap, but Claude Code's skill system gave the team the right foundation to ship something useful now.

Wingspan covers the workflow; the VGV AI Flutter Plugin covers the conventions. When the two are used together, teams get end-to-end coverage of Flutter engineering workflows.

The plugin provides Claude Code with skills for accessibility, testing, Bloc state management, layered architecture, and more. Wingspan's four-phase workflow ensures those skills are applied at the right time, in the right order.

The result is that the agent does not just generate Flutter code. It generates Flutter code that follows a consistent architecture, includes meaningful tests, and respects the conventions a team has agreed on.

While Flutter is the home turf, Wingspan is not limited to it. The workflow phases are stack-agnostic by design.

• Clone the open-source repository from GitHub and review the workflow definitions
• Install the slash commands into your Claude Code configuration
• Pair Wingspan with the VGV AI Flutter Plugin for Flutter-specific conventions
• Run a session on a small feature first, then scale to larger work

Getting started with the alpha release is straightforward, and the repository includes everything needed to run a first session.

This is an alpha release, and the team is actively iterating on the workflow based on how it is used internally and on feedback from the community.

Wingspan is one piece of a broader investment in AI-native engineering at VGV. The company is also building internal tooling, including the Very Good AI Assistant, that applies agentic workflows to large, complex engineering challenges.

For now, the focus is on making Wingspan's core workflow as solid as possible. The value is already real even in alpha, and the team is sharing it early.