The Starters consist of 3 main repos:
The API and SPA are plain Laravel and Vue codebases with nothing AI specific baked in, so they work fine on their own. The flows and agent files are just a starting point for agentic coding and can be removed or swapped for other agent tools as needed.
These are full starter apps rather than bare starter kits, with auth, billing, admin, localization and more already working out of the box. The quickest way to see what's included is to try the demos and look through the docs and source code for yourself.
Demos: Vue App, Vue Admin, Flows
Source: Laravel API, Vue SPA, Flows
There's nothing particularly new about a flows driven workflow. "Flows" is just a stand-in for docs, user flows, system flows, architecture diagrams and so on, and pretty much every project has some form of it. In practice though, it rarely plays out the way it should. Documentation becomes an afterthought, new features don't get documented, existing docs don't get updated, and it all slowly drifts from what's actually implemented until it's stale and a burden to maintain.
Agentic coding changes that. Agents take on most of the grunt work, keeping the docs in sync and writing a large portion of the code. That frees you up to focus on app design, architecture, edge cases, security and the user and system flows themselves. And since the docs are no longer a chore to maintain, they can sit front and center in the process and give you a bird's-eye view of the whole app.
That same bird's-eye view makes working with clients and non-technical team members a lot easier. They send over a set of requirements, you work through them together at the spec level, and the agents build from there. Nobody has to read code to follow along. When an issue comes back, you review the flow, adjust it and implement again. Wash, rinse, repeat.
The concept is simple. Every new feature starts from the flows. Each code repo includes a .local agent file, ignored by git, that points to wherever your flows directory lives, so you can prompt against a flow straight from the code side. The format in the current flows repo works relatively well, but is still a work in progress. Add sections, rework the structure or set it up however suits your app or team. What matters is having something central driving it all.
It also works both ways. Most of the time flows lead to code, but some things are easier to work out in the code first and document after. While building the Stripe setup, for example, the API needed a container to forward Stripe webhooks locally. A pre-built image already exists for that, so the agent had it set up right away, and a quick prompt from the API repo updated the Docker doc in the flows to match. Review the change, commit and move on. Hot fixes, architecture changes or anything else added directly in code works the same way.
Some drift will still creep in over time, but it tends to show up sooner rather than later as features are updated. When you prompt the agent against a flow, it gives you a breakdown of what's out of sync, so you can tidy things up right away as part of the normal development lifecycle.