In the first article in this series, we explained how to prepare a computer for vibe coding. We installed Linux, set up Codex and Antigravity, connected GitHub and published our first application using Railway.
We managed to develop a small application with AI without writing the code ourselves.
But that was a test. We asked Codex to write the code, checked that it worked, and then used Antigravity to review the result. That's fine as a starting point, but if we want to work on real projects, we need something more organized.
What happens when we have several features waiting to be built? How do we stop AI from changing files it shouldn't touch? Who checks that a proposed solution makes sense before it's coded? And how do we know that what we publish is exactly what we reviewed?
To answer these questions, I've gradually developed my own workflow. I haven't invented anything revolutionary: I've adapted standard professional development practices to an environment in which AI agents do much of the work.
I'll explain how to organize and use it step by step, in case it helps you replicate it.
How I organize work with AI agents
The idea is simple: one AI develops the software and another audits its work, while we retain control of the important decisions.
I use five core tools:
| Tool | Role |
| Codex | Analyzes, plans, codes, tests and documents. |
| Antigravity | Independently audits the plan and the code. |
| GitHub | Stores the code, versions and pull requests. |
| Linear | Organizes tasks, tests, audits and statuses. |
| Notion | Stores requirements, decisions and the project's history. |
I add a couple more: Local WP for WordPress development, and Convex or Supabase if it's a web application that needs a database.
Notion is optional, although I recommend it for medium-sized projects. We'll see why later.
We don't have to use exactly these applications, either. We could replace Codex with Claude Code, for example, or use another agent as the auditor. The essential thing is to keep responsibilities separate.
The full procedure is:
- Requirements.
- Technical plan.
- First audit.
- Development and testing.
- Second audit.
- GitHub.
- Deployment.
- Verification.
Steps 2 (Codex) and 3 (Antigravity) can be repeated several times: if Antigravity finds a problem, Codex fixes it and we repeat the review. The idea is to move forward through cycles of work and verification, without proceeding to the next phase while significant problems remain unresolved.
My workflow includes two mandatory audits, although their depth depends on the complexity of the development. The first reviews what we intend to do; the second checks what we have actually done.
And one important thing: an auditor's GO is not authorization to publish. That decision is still ours.
Step 1. Set up our working environment with Codex
We start with the computer configured in the first tutorial. Codex, Antigravity and GitHub are already working, so we won't repeat the installation steps.
Open a terminal in our project folder and start Codex:
cd ~/Proyectos/mi-proyecto
codex
Now comes one of my favorite aspects of working with agents: we don't need to set up the entire project structure manually. We can ask Codex to do it.
Prompt 1. Configure the working environment
I want to prepare this project for an AI-supervised development workflow.
You will act as analyst and developer. Antigravity will be the independent auditor. We will use GitHub for code, Linear for tasks and, optionally, Notion for documentation.
Inspect the project and check the available connections. Propose permanent instructions, minimum documentation, permission rules and a workflow with two mandatory audits: of the technical plan and of the code.
Implementations, major Git operations and deployments require human authorization. Tasks are only closed after production has been verified.
First present a configuration plan. Do not create files or modify services until you receive authorization.
Codex should analyze what we have available and tell us what's missing.
There will usually be some operations we have to carry out ourselves:
- Sign in to Linear or Notion.
- Authorize an integration.
- Accept permissions or establish a connection that requires browser authentication.
VERY IMPORTANT: we must not give it passwords or tokens by pasting them directly into the chat.
We'll use each service's authentication mechanisms (GitHub and Cloudflare have them) and grant only the permissions needed.
Once we approve the configuration, Codex can prepare the files and organize the tools.
But we'll check that it really has done so, which means we'll ask it to verify its work. An agent cannot create a connection to Linear if its environment has no compatible integration.
Step 2. Organize documentation without filling the repository with files
To work with agents, we need something that conversations alone don't provide: the project's operational memory.
Imagine we've been developing for several weeks and start a new Codex session. We don't want to explain the entire architecture again, what tools we use, which files it can touch and how deployment works.
To avoid that, we'll use two basic documents in the repository:
- AGENTS.md: permanent instructions for Codex, boundaries on its actions and development rules.
- PROJECT.md: project description, basic architecture, environments and links to documentation.
Codex can create them based on our requirements.
So why do we need Notion?
On small projects, Markdown files may be enough to document changes and decisions. But as features, decisions, requirements and architectural changes accumulate, we end up with too many documents in the repository.
That's why I recommend Notion for medium-sized projects.
This is where we'll mainly store PRDs (Product Requirements Document), technical decisions and project history. Linear will track tasks, their statuses, audits and tests. GitHub will store the code.
What's interesting is that Notion and Linear will mainly be used by the agents themselves. Codex will write and update documentation, consult requirements before coding and record results. Antigravity will need to read that information for its audits.
We won't have to write pages and pages of documentation ourselves. Our responsibility will be to check that the requirements and important decisions reflect what we want.
Step 3. Define what we want to develop
We'll use a real feature I developed for this website as an example.
On my magazine site, tag pages displayed posts in chronological order. I wanted to improve them so that they highlighted the most interesting content without losing the usual listing.
This is the kind of need we can explain to Codex in natural language, knowing that a request like this leaves plenty of questions unanswered.
- How many articles should we feature?
- How do we decide which are relevant?
- What happens to the rest?
- Should it work on every page?
- Which elements do we not want to change?
It's worth answering these questions before analyzing anything.
Prompt 2. Prepare requirements and technical plan
I want to develop this feature: [DESCRIPTION].
Read the project's instructions and documentation. Turn the need into testable requirements and acceptance criteria. Prepare or update the PRD and organize the necessary tasks in Linear.
Examine the existing code and propose the simplest solution that meets the requirements, identifying affected files, risks, alternatives and tests.
Don't write code yet. Ask me about functional decisions you cannot resolve with the available information, and prepare the plan for an independent audit.
This is one of the biggest changes compared with simply asking an AI to code something.
Codex can help us turn an idea into a specification. We decide whether that specification represents our needs.
With the tag pages, for example, the acceptance criteria couldn't simply be that featured articles appeared. We also needed to preserve navigation, avoid unwanted duplicates and ensure everything worked properly across the different pages.
Once we've approved the approach, Codex records it and prepares the technical plan.
We haven't written a single line of code yet.
Front-end design
In this case, I knew exactly what design I wanted, so I didn't ask for visual proposals. However, on other occasions I would ask for them at this stage, so that they could be considered before proposing the technical solution.
Obviously, if you know what you want, just explain it. Or, if you need a feature that affects the back end rather than the front end, you won't need mockups either.
Step 4. First audit: check the plan with Antigravity
Now our second agent comes into play.
Open another terminal in the same project folder and run:
agy
In my current workflow, Antigravity runs manually. We don't let Codex invoke it automatically and carry on without us reviewing the result.
We want it to act as an independent auditor, not another developer who starts modifying files.
Prompt 3. Audit the technical plan
Act exclusively as an independent technical auditor.
Review the project instructions, requirements and plan proposed by Codex. Assess whether the solution is viable, sufficiently simple, secure and compatible with existing functionality.
Check the risks, possible regressions and whether the planned tests are appropriate.
Issue a reasoned verdict: GO, conditional GO or NO-GO. If you lack sufficient evidence, state that explicitly.
Identify specific problems and the necessary corrections. Do not modify any files.
Why audit before development?
Because a solution can be coded perfectly and still be a bad solution.
Perhaps it introduces an unnecessary dependency, duplicates existing information, runs too many queries or makes future maintenance harder.
With the tag pages, for example, creating a featured-content system wasn't enough. We also had to consider how to calculate its order without running slow operations every time someone visited a page.
If the auditor identifies problems, we pass its report to Codex. Codex revises the plan and we audit it again whenever necessary.
Coding doesn't start until the plan is accepted and a human authorizes its implementation.
Step 5. Codex develops and runs tests
With the plan approved, implementation begins.
Codex works on a repository branch. If you've read the first article, you're already familiar with Git and GitHub, so we don't need to repeat how to use them.
What's new is that we don't code directly on the project's stable version. We prepare changes separately so we can review them before integrating them.
Prompt 4. Implement the feature
I authorize development of the approved and audited plan for [LINEAR TASK].
Work on a dedicated branch and limit changes to the authorized scope.
Implement the solution, run the relevant tests and check for possible regressions. Document the results in Linear.
Prepare the full diff, identify modified files and provide the evidence needed for the second audit.
Do not merge or deploy. Stop when development is ready for review.
Codex may modify files, run tests and fix errors within the scope we've approved.
But there's one thing we need to watch out for: an AI claiming that a feature works does not mean it has actually been verified.
We need evidence. Depending on the project, that might mean automated tests, execution results, functional checks or a combination of these.
We also need to distinguish between what Codex has tested and what it still cannot verify.
Back to our example: it isn't enough to check that three featured articles appear. We need to see what happens when fewer articles are available, when we change pages or when some content lacks the expected data, such as an article not translated into one of the languages.
The agent must record those checks and any limitations.
Step 6. Second audit: review the actual code
We've developed the feature, but we're not going to publish it yet.
We return to Antigravity and ask it to review the modified code, not merely the report Codex has prepared.
Prompt 5. Audit the implementation
Act as independent technical auditor for [LINEAR TASK].
Review the full diff, approved plan, requirements and testing evidence.
Look for functional defects, security issues, regressions, unnecessary complexity and changes outside the authorized scope.
Issue a reasoned verdict and identify findings by file and location wherever possible.
Record the SHA-256 hash of the audited diff to identify exactly which version was reviewed.
Do not modify files or authorize commits, merges or deployments.
There are two important details.
First, Antigravity must be able to consult the same rules and requirements that Codex used. Otherwise, it risks approving a technically sound solution that doesn't meet what we asked for.
Second, we must preserve documentation of the audited set of changes. This lets us identify the exact version that received a GO and detect whether the code has changed afterward. That fingerprint must be calculated reproducibly from the same content.
In my case, we store the complete record in Linear, linked to the relevant task.
If Antigravity finds errors, we go back to Codex, request corrections and repeat the audit.
Two agents can both be wrong, even when they agree. That's why audits are extra safeguards, not absolute guarantees. And why we can optionally add a third.
Step 7. Integrate changes into GitHub
Once we have a GO from the audit, we can prepare the integration. The usual procedure is:
Branch > Commit > Push > Pull Request > Merge.
We don't need to run those commands manually. Codex can handle them, but we must understand what we're authorizing.
The pull request lets us review which changes we intend to add to the main branch, the tests supporting them and the auditor's recommendations.
We should also check that the version we're about to integrate is still the one that was audited. If we change the code after receiving a GO, that verdict may no longer be valid.
I prefer explicit authorization for major operations. We can group some when the scope is very clear, but we shouldn't grant unlimited freedom to merge and publish.
The auditor deciding that a feature is correct is one thing; our deciding to integrate it is another.
This is where a third AI could come in: we can add a second specialist auditor, such as CodeRabbit.
Unlike Antigravity, which we use to review the plan and code locally, CodeRabbit can automatically analyze GitHub pull requests before they're merged.
It's an interesting extra review for important projects, although it isn't essential and costs money, albeit little considering what it offers. For now, I prefer to keep the two manual audits and consider a third review when the project grows.
Step 8. Deploy and check functionality in production
This step depends considerably on where the project is hosted.
In the first article, we used Railway. We could also deploy using GitHub Actions, tools provided by our hosting service or any other deployment system.
We'll cover the specifics of WordPress, LocalWP and Webempresa in another article.
Here we're interested in one general rule: a successful deployment doesn't mean the feature is working correctly.
Once the change is published, we must check the real application.
In our example, that means visiting the public pages, checking featured articles, navigating the list and making sure we haven't changed other functionality.
We also need to confirm that the new version is being displayed. Sometimes code is deployed correctly but a cache continues to serve old content, as happened to me with WP Rocket.
For important developments, we should plan how to restore the stable version if something goes wrong.
Only after these checks can we say the feature is finished.
Step 9. Close the task and prepare the next development
Once the result is verified, we ask Codex to update Linear and the project documentation.
It should record what was developed, which version is live, which tests we've run and whether any issues remain.
The task is marked complete after verification in production, not when Codex finishes coding or Antigravity issues its GO.
This documentation has another advantage: we can end the session and start a new one without losing context.
In fact, I recommend doing that when we start a different feature. Agents can retrieve rules, requirements and decisions from the project documents instead of relying on endless conversations.
Over time, we can automate some of the coordination between Codex and Antigravity, although for now I prefer to keep it manual, check that the procedure works and build confidence before removing oversight steps.
Is working this way worth it for every development project?
No.
To create a test or experiment for twenty minutes, preparing documentation, two audits and a publishing process is overkill.
But when we're developing a real website, an application for a client or a project we'll maintain for months, that extra work makes perfect sense.
The advantage of this procedure isn't that it eliminates errors or replaces programming knowledge. It helps us work more systematically, preserve decisions and catch problems before they reach users. We minimize the errors typical of early-stage vibe coding.
And because agents handle most of the operational tasks, our involvement focuses on what matters: deciding what we want, approving how we'll do it and checking that the result works.
Conclusion
In the first article we prepared the computer. In this one we've prepared the way we work.
Now we know how to:
- Turn a need into requirements.
- Ask Codex for a plan.
- Audit it with Antigravity.
- Develop a feature.
- Review the code.
- Publish it with version control.
- Document everything.
It's not simply about programming faster with artificial intelligence, but about being able to maintain what we develop, understand what's changed and have a procedure for fixing problems when they arise.
In the next installment, we'll apply this workflow to WordPress: local development, tests, version-controlled files and deployments to a real hosting service.
Frequently asked questions
Do I need to know how to program to use this procedure?
You don't have to write code, but you do need to understand basic development concepts and learn to interpret tests and risks. AI doesn't remove our responsibility for the outcome.
Do I have to use Codex and Antigravity?
No. You can replace them with other coding and review agents. What matters is separating responsibilities and preventing the developer from being the only one who evaluates their own work.
Do I need Notion and Linear?
Linear is the task management tool we use in this tutorial. Notion is optional for simple projects, although I recommend it when requirements, decisions and documentation accumulate. An alternative is to keep that information in Markdown.
What should I do when Antigravity issues a NO-GO?
Pass the report to Codex, ask it to fix the problems and repeat the audit. Don't automatically advance to the next phase.
Why audit twice?
Because the first audit looks for problems in the plan and the second checks its implementation. Reviewing only the code can miss design mistakes that would have been easier to fix beforehand.
Can I use this workflow with WordPress or other technologies?
Yes. The procedure works regardless of language or platform. What changes are the tests, environments and deployment mechanisms.
When is a task really finished?
When the authorized version is live, its operation has been verified in production, and the evidence and decisions have been recorded.

Leave a Reply