VGV Wingspan: An 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 we have been wrestling with at VGV as we build 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 our 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.

We are releasing Wingspan today in alpha (v0.0.1). It is open source, it is built for Claude Code first, and it encodes the engineering practices we use every day at VGV. You can explore the full codebase on GitHub: Wingspan on GitHub.

What Is An Agentic SDLC?

A traditional software development lifecycle (SDLC) 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. The architecture emerges by accident rather than by design.

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. Wingspan operationalizes that principle by making each phase a concrete step the agent must complete.

The Four Workflow Phases

Wingspan organizes every engineering session into four phases, each invoked as a Claude Code slash command:

/brainstorm

The brainstorm phase is where you and the agent explore the problem space together. Before any code is written, /brainstorm helps surface requirements, identify edge cases, and clarify scope. The agent asks questions, proposes approaches, and documents the constraints that will guide every subsequent phase.

/plan

Once the problem is well understood, /plan 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.

/build

With a plan in hand, /build executes the implementation. The agent writes code that follows the plan, respects the architecture decisions made in the planning phase, and adheres to project conventions. Because the plan exists as a reference, the agent stays on track rather than inventing its own path.

/review

After the build is complete, /review evaluates the result. The agent checks the implementation against the original plan, flags deviations, verifies test coverage, and surfaces potential issues that a standard code review might miss. The review phase can loop back to brainstorm if significant gaps are found, creating an iterative cycle.

Why Claude Code First?

We chose Claude Code 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 rather than just a completion engine. Claude Code’s architecture made it possible to build a structured, multi-phase workflow that feels natural inside a developer’s terminal.

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

End-to-End Flutter Engineering with the VGV AI Flutter Plugin

Wingspan covers the workflow. The VGV AI Flutter Plugin covers the conventions.

When you use Wingspan together with the VGV AI Flutter Plugin, you get end-to-end coverage of Flutter engineering workflows that follow VGV’s established practices. 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: the agent does not just generate Flutter code. It generates Flutter code that follows a consistent architecture, includes meaningful tests, and respects the conventions your team has agreed on.

Beyond Flutter: All Tech Stacks Supported

While Flutter is our home turf, Wingspan is not limited to it. The workflow phases are stack-agnostic by design. Teams working with web, native, or embedded systems can use the same brainstorm, plan, build, and review loop to bring structure to their agentic coding sessions.

The Flutter-specific depth comes from the VGV AI Flutter Plugin integration. For other stacks, Wingspan provides the workflow structure while you bring your own conventions and tooling.

Getting Started

Wingspan is open source and available now in alpha. To get started:

1. Visit the Wingspan repository on GitHub.
2. Follow the installation instructions in the README to add Wingspan’s skills to your Claude Code environment.
3. Open a project in Claude Code and try /brainstorm to start your first structured engineering session.

This is an alpha release (v0.0.1). We are actively iterating on the workflow based on how we use it internally and on feedback from the community. If you find issues or have ideas, open an issue on the repo. We want to hear from you.

What’s Next

Wingspan is one piece of a broader investment we are making in AI-native engineering at VGV. We are also building internal tooling, Very Good AI Assistant, that applies agentic workflows to large, complex engineering challenges: native-to-Flutter code migrations, comprehensive code assessments, and Figma-to-code patterns at scale. We will have more to share on that in a future post.

For now, we are focused on making Wingspan’s core workflow as solid as possible. We are sharing it early because the value is already real — even in alpha.

Give Wingspan a try. Star the repo. Open an issue. And if your team is tackling agentic engineering challenges that go beyond what open-source tooling can solve, we would love to talk.