Flow is the official AdonisJS harness for coding agents. It works inside the agent you already use, whether that's Claude Code, Codex, Cursor, GitHub Copilot or OpenCode.
Those agents know how to write code. Flow teaches them how an AdonisJS app should be built, and checks their work against it.
Before your agent writes a line of code, Flow gives it docs matched to the package versions in your app, and skills that settle design decisions the way we would. Where does this code go? Which layer validates this input? What deserves a test?
Once the agent is done, lint rules check every change, and every pull request gets a review against those same decisions.
Flow is part of AdonisJS Plus, our paid membership that funds the work on the framework. Let's start with why it exists.
A shift towards automation
Agents now write a large part of the code we ship. Writing code is no longer the slow part. Reading it is.
More of us are now automating the work around the agent as well, like planning the work, opening pull requests and reviewing them. Some call the result a software factory.
I use the term, but not literally. A factory suggests code rolling off an assembly line with nobody watching. That is not what I mean. A person still decides what gets built, and what is good enough to ship. What changes is how much of the implementation you hand over, and how much of it you read line by line.
I have been working this way for a while. The whole of AdonisJS Plus, including its website, package registry and dashboard, was built by a small factory I set up for myself. I describe the work in issues, agents open the pull requests, and I decide what gets merged.
Context engineering
A factory is only as good as the context its agents work with. Give an agent vague or wrong context, and it fills the gaps with guesses. You end up reading every line anyway.
Getting this right is called context engineering. It means giving the agent enough of the right context that you can trust its output more often.
Context engineering has two halves.
- Your product. The decisions you have made, the trade-offs you prefer, your taste.
- Your tech stack. How the framework works, and how an app built with it should be designed.
Only you can write the first half. Nobody else knows your product.
The second half is different. It is mostly the same for every AdonisJS app. Every team writing its own version, and keeping it current with every release, is wasted effort. It should come from the people who build the framework.
That half is Flow. It is written by the people who build AdonisJS, and it changes when the framework changes. When a new version of Lucid or VineJS ships, the docs your agent reads are updated for it.
The context quadrants
Teaching an agent your stack is not one thing. Some guidance reaches the agent before it writes code, and some checks the code after. We call these feed forward and feedback.
Either kind can be run by a tool that gives the same answer every time, or by a model that makes a judgment. These are computational and inferential.
That makes four quadrants, and you need all four. Guidance without checks never finds out whether it worked. Checks without guidance catch the same mistake again and again.
Diagram from Joël Quenneville's talk Harness Engineering on Rails . Birgitta Böckeler describes the same model in Harness engineering for coding agent users .
Generators - Feed forward, computational
AdonisJS generators like node ace make:controller create each file in the right place and shape, every time. But agents usually don't use them. They write the files by hand, and each one comes out a little different.
Flow's skills tell the agent to run the generator first, then fill in the code.
Docs and skills - Feed forward, inferential
Models learn AdonisJS from whatever was online when they were trained. That mixes versions, so the code they write often uses APIs that have since changed.
Flow installs docs for the packages in your app, matched to the major version you use. They are written for agents, not people. They skip what an agent already knows, and give firm rules where it would otherwise guess.
Docs explain how the framework works, not how to design an app. Ask an agent for the same feature twice, and you can get two different structures.
Skills fix that. Each one settles one kind of design decision, like where code goes, which layer validates input, or what deserves a test. Flow ships eight of them. Type /flow- in your agent to see the list.
The access control skill, for example, makes sure every query only loads records the current user is allowed to see, including on list pages and bulk updates.
Lint rules - Feedback, computational
Some conventions are deterministic, and a tool can detect them by parsing the code. Flow ships them as ast-grep rules that run through ESLint, so they report in your editor, in npm run lint and in CI, whoever wrote the code. Your agent doesn't need to remember them.
Some check how your app code is organised, others check your tests.
Pull request reviews - Feedback, inferential
Flow reviews each pull request for the problems AdonisJS apps actually run into. A controller action that loads another user's record without checking who owns it. A list page that runs one query per row because a relation wasn't preloaded. A migration that locks a large table during a deploy. Request data that reaches your code without passing through a validator.
The review checks the code against the same rules the skills teach your agent.
- Use it alongside CodeRabbit, Pullfrog or any other generic code reviewer.
- Bring your own agent API keys or subscriptions. We don't sell credits or tokens.
- Your code never reaches our servers. Reviews run in your own GitHub Actions.
- Run it locally with
npx @adonisplus/flow review.
Feature packs
Some features show up in almost every app, like authentication, password resets or two-factor. They are security critical, easy to get wrong, and barely change from one app to the next.
Before agents, the usual answer was a template. You start from a starter kit that already has these features, and remove what you don't need. But templates are rigid. They come with more code than you need, and that code is hard to change once it is in your app.
A feature pack is a recipe for one feature instead. It covers the parts that should not change between apps, like making sure a password reset never reveals which emails have an account. Your agent doesn't have to reinvent those parts.
What does change between apps is the user flow, the design and small adjustments. Agents handle that kind of work well.
Get Flow as part of your Plus membership
Flow is part of AdonisJS Plus. A Plus membership also funds the work on AdonisJS itself, which stays free and open source.
If your development workflow relies heavily on AI, give Flow a try, and help us build a sustainable ecosystem around the framework.