How to prepare your PC for vibe coding step by step

This article is the first in a series in which I'll explain how to start vibe coding from scratch.. 

Not just how to ask an AI to write code and leave it at that, but how to do it properly, with a system that minimizes errors and ensures a certain level of code quality. We'll also document everything, track code changes and have a testing system. Just like professional development teams, but without having to be a developer.

The first step, then, is to prepare our computer and configure the necessary tools.

By the end of this first tutorial, we'll have a computer ready for vibe coding and we'll have published a small test application using GitHub and Railway.

Why I recommend Linux for vibe coding

You can do vibe coding perfectly well on Windows, Linux or macOS. The main AI tools work on all three systems, either directly or through compatible environments.

I'm going to use Linux, because it makes quite a few things easier and is likely to cause fewer errors than Windows. If we insist on using Windows, we can use WSL2 to run a Linux environment inside Windows 11. But that introduces another configuration layer that can make things harder when problems crop up.

With Linux, we work directly in the environment where we'll run the tools, without relying on an additional subsystem.

And what about macOS? I don't use it, so I can't say for sure, but from what I've seen of the Mac Mini's success, and knowing that its terminal and Unix environment allow a workflow very similar to Linux, I get the impression that it's just as suitable for development.

Better to use a secondary computer or a separate drive

I also recommend not using our main work computer to experiment with development and AI agents, especially while we're learning.

Not because these tools are dangerous per se, although they can be, but because they may install dependencies, execute commands, modify files and carry out actions we'd rather they didn't.

That's why I prefer keeping that environment separate from the computer I use for work every day. You know I'd rather keep my PC activities compartmentalized than regret not doing so later.

Ideally, we'd use a second computer, but there's no need to buy another one. If you don't have one, a solution I particularly like is installing Linux on an external SSD and booting it over USB on a compatible PC..

That way I can boot Linux whenever I want to develop and continue using Windows normally the rest of the time. The programs, projects and settings stay on the SSD, with no need to create a Linux partition on the main drive.

That said, it's not complete isolation: Linux can access other connected drives if we mount them and grant it permission. We still need to be careful about what we authorize it to run.

In my case, I'll use the setup described in the article: Linux Mint Xfce installed on a SATA SSD inside a USB 3.0 enclosure.

From now on, I'll assume you've already installed Linux Mint, that it boots properly and that you're connected to the internet.

What tools do we need for vibe coding?

Before starting, it's worth knowing what we'll install and why.

Tool	Purpose
Linux Mint Xfce	Operating system
Terminal	Run commands and agents
Git	Code version control
Node.js	Run JavaScript tools and applications
npm	Install JavaScript packages
Codex	AI coding agent
Antigravity	Second agent, acting as auditor
Claude Code	Alternative to Codex or second paid agent
GitHub	Code repositories
Railway	Publish applications online
Linear	Project and task management
Notion	Documentation and requirements, optional
LocalWP	Local WordPress development, optional

Most of these tools are free or offer free tiers. You can start with Codex on a free ChatGPT plan, subject to usage limits. Paid subscriptions are useful if you need more capacity.

My system: one AI codes and another audits

We could do everything with a single AI, but I prefer working with two agents that perform different roles:

• Analyst-programmer: interprets requirements, proposes solutions, writes code and fixes errors.
• Auditor: reviews changes, looks for problems and checks that what we've built meets the requirements.

The idea is that the AI reviewing the work shouldn't be the same one that did it, because a well-designed independent review can catch mistakes the first agent missed.

I'll explain the loop system properly in another upcoming article.

Which combination of AI tools should you choose?

I see three interesting options.

Paid subscriptions	Analyst-programmer	Auditor
Paid ChatGPT	Codex	Antigravity
Paid Claude	Claude Code	Antigravity
Paid ChatGPT + Claude	Claude Code	Codex

In this tutorial I'll use the first option: Codex as analyst-programmer and Antigravity as auditor.

If your ChatGPT subscription costs €18 a month, you can use Antigravity’s free access for the audit and avoid paying for a second subscription. This way:

• You don't pay for two AI services.
• You can use Codex within the usage limits of your ChatGPT plan.
• A model from a different family can review the code.

Antigravity offers free access subject to the current terms and usage limits, which can change, mind you. 

If you only pay for Claude, you can replace Codex with Claude Code and keep Antigravity as auditor.

And if you pay for both ChatGPT and Claude, I suggest using Claude Code as analyst-programmer and Codex as auditor. It’s the combination I’d choose if I were paying for both services, but you have to pay for two tools.

Right, now that we've listed the tools, let's get into the tutorial itself.

Step 1. Update Linux Mint

Open the Linux Mint terminal.

In Xfce, we can open it from the applications menu or with the Ctrl + Alt + T shortcut.

First, update the repository information and install any available updates:

sudo apt update && sudo apt upgrade -y

Linux will ask us for the user's password.

If the update installs important system components or a new kernel version, it's worth rebooting before continuing.

Now install the basic tools:

sudo apt install -y curl git ca-certificates

This gives us:

• curl, to download resources from the internet.
• git, to manage repositories.
• ca-certificates, to validate HTTPS connection certificates.

Check that Git works:

git –version

It should return the version number.

A detail about the terminal and its cache

During installation, a tool may install correctly but the terminal may claim that its command doesn't exist.

This often happens because the installer has added a new folder to the PATH environment variable, and our terminal hasn't loaded the change yet.

That's why it's advisable to close the terminal completely (not just its tab) and open a new one after installing tools that modify the environment.

Restart the terminal session to load its updated configuration.

Step 2. Install Node.js and npm

Node.js lets us run JavaScript outside the browser.

We'll use it for web projects, automation and development tools. npm is its package manager, making it easy to install dependencies.

To keep this tutorial simple, we'll use the LTS version of Node.js through NodeSource.

First, download the setup script:

curl -fsSL https://deb.nodesource.com/setup_lts.x -o nodesource_setup.sh

Run it:

sudo -E bash nodesource_setup.sh

And install Node.js:

sudo apt install -y nodejs

Now check both programs:

node –version

npm –version

If they display their respective versions, we can continue.

We can also delete the downloaded script:

rm nodesource_setup.sh

Node.js isn't needed to run the standalone versions of Codex or Claude Code, but we'll use it for web projects and other tools.

Step 3. Install Codex, our analyst-programmer

Codex is OpenAI's coding agent. It can explore files, modify code, execute commands, analyze errors and help us work with complete projects from the terminal.

To install it, use the official installer:

curl -fsSL https://chatgpt.com/codex/install.sh | sh

Or via npm:

npm install -g @openai/codex

We don't need to run both commands. In this tutorial we'll use the standalone installer.

Then check:

codex –version

If the terminal doesn't recognize the command, close it completely and open a new one.

Connect Codex to ChatGPT

To start Codex, type:

codex

The first time, it will offer the available authentication methods.

Choose sign in with ChatGPT, open the browser when prompted and authorize the connection.

Once we're in, we can explore the commands.

For example, to choose from the available models and reasoning levels:

/model

To check the session status:

/status

And to review the permissions the agent will have:

/permissions

The available models will depend on our account and the version of Codex.

Important: I don't recommend giving the agent unlimited permissions from the outset. Even if we've set up a new drive for this, it's better to review operations involving important files, external commands or connected services manually.

Alternative: install Claude Code

If you've chosen Claude Code as your analyst-programmer, the process is similar.

Install its official client:

curl -fsSL https://claude.ai/install.sh | bash

Check:

claude –version

And run the diagnostics:

claude doctor

To start the agent:

claude

Follow the authentication process.

I'll use Codex for the rest of the tutorial, but the development instructions can be adapted to Claude Code.

Step 4. Install Antigravity as auditor

Now we'll install our second agent.

Antigravity has a graphical application, but here we're interested in its CLI version, which we can run directly from the terminal.

The official Linux installer is:

curl -fsSL https://antigravity.google/cli/install.sh | bash

The default location of the executable is:

~/.local/bin/agy

Check:

~/.local/bin/agy –version

If it works directly with agy, there's nothing more to do.

Otherwise, we can add its directory to PATH:

echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc

Close the terminal completely and open a new one.

Check:

agy –version

Sign in to Antigravity

Open:

agy

On first launch, follow its setup wizard.

We'll be able to choose display preferences and complete authentication using the methods offered by our account.

We also need to confirm that we trust the project folder before allowing the agent to access its files.

There's no need to configure any automatic audits yet. We'll do that when we have our first project.

Important: the agents can share a repository, but it's best not to let both modify the same files simultaneously. That's why one will develop and the other will review.

Step 5. Install GitHub CLI

We already have Git, but we still need to connect our computer to GitHub.

Git lets us manage versions locally. GitHub hosts remote repositories, supports collaboration and keeps our code outside the computer.

Install GitHub CLI:

sudo apt install -y gh

Check:

gh –version

Configure our Git identity

Before making commits, specify the name and email we want associated with our changes:

git config –global user.name "Tu Nombre"

git config –global user.email "tu-correo@example.com"

Replace those example values with your own details.

We can check the configuration:

git config –global –list

Authenticate with GitHub

Run:

gh auth login

Select GitHub.com and follow the instructions.

If we choose browser authentication, GitHub CLI will show us a temporary code and a URL where we can enter it.

Once access is authorized:

gh auth status

This will confirm that GitHub CLI recognizes our account.

For professional projects we'll use private repositories and avoid putting passwords or API keys in the code..

Step 6. Install Railway

Railway is a platform for publishing applications without having to configure and manage our own server directly.

In this tutorial, we'll initially use it to publish a small HTML website and check that the workflow works.

Using Railway isn't mandatory for vibe coding. We could use other providers such as Vercel, but it's useful for checking that our code can go from a local repository to an application accessible on the internet.

Install Railway CLI:

bash <(curl -fsSL https://railway.com/install.sh)

You can also install it through npm:

npm install -g @railway/cli

Choose just one of the two methods.

Check:

railway –version

Connect Railway

First, create an account at:

https://railway.com

Then, from the terminal:

railway login

The browser will open so you can authorize access.

We can check which account is connected:

railway whoami

Railway offers plans with limited credits and paid plans. Before publishing services that will run permanently, it's worth checking the terms and usage limits.

Step 7. Set up Linear and, optionally, Notion

We won't install desktop applications for these two tools.

Linear will be our project manager. Here we'll organize features, bugs, tasks and releases.

We can create an account at:

https://linear.app

Later, we'll set up a project and decide how to connect it to our development workflow.

Notion will be optional. We can use it to write requirements documents or PRDs (Product Requirements Document).).

For simple projects, we can also save the requirements in a Markdown file within the Git repository itself. Documentation is useful when it helps us make decisions and clarify what needs to be built. We don't need to write lengthy documents for every tiny change.

For now, we only need to create the accounts and check that we can log in.

Step 8. Review the privacy settings of the AI tools

Before using agents with real client code, it's worth reviewing their privacy options.

In ChatGPT, we can go to Settings > Data Controls and disable the option to use our conversations to improve the models. We should also review the specific controls that apply to Codex.

In Claude and Antigravity, we'll check their respective settings for using data to improve products, retention, telemetry and marketing communications. Each service has its own terms.

And there's one thing we need to be clear about: disabling training doesn't mean that the code is no longer sent to the AI provider. Cloud-hosted models need to receive the information required to do their job.

That's why we'll follow some basic rules: 

• Don't share private keys, passwords or tokens.
• Keep credentials out of GitHub.
• Restrict each tool's permissions to what it needs.

Step 9. Check everything before starting

Now close the terminal completely and reopen it.

Check the development tools:

git –version

node –version

npm –version

GitHub and Railway:

gh –version

railway –version

And our AI tools:

codex –version

agy –version

If we're using Claude Code:

claude –version

claude doctor

Also check that we're still authenticated:

gh auth status

railway whoami

Version checks tell us that the programs are installed. Authentication checks tell us that we can access our accounts.

But we still need to run a complete functional test.

Step 10. Create our first development folder

We're going to create a small website to make sure everything works.

In Linux Mint, we can create a folder on the desktop and open a terminal directly in it.

Alternatively, we can use commands:

mkdir -p ~/Proyectos/mi-primera-app

cd ~/Proyectos/mi-primera-app

It's important to launch Codex from the project folder. That way, the agent can work with the necessary files without having to explore our entire computer.

Step 11. Ask Codex to build an application

Start it:

codex

Now ask it to create a simple application:

I want an HTML, CSS and JavaScript application that lets me create a to-do list, mark tasks as completed and delete them. Store the tasks in the browser's local storage so they don't disappear when the page reloads. The interface should be responsive and work on mobile and desktop. Use separate files and avoid unnecessary frameworks or dependencies. Also prepare a README with instructions for running it.

Codex will analyze the requirements and create the corresponding files.

Once it's finished, check what it has generated. In a project like this, we might see something as simple as:

mi-primera-app/

├── index.html

├── style.css

├── script.js

└── README.md

If there are no dependencies or compilation steps, we can open the HTML directly in the browser.

For a test closer to a real server, we can also use Python, which is normally available in Linux Mint:

python3 -m http.server 8000

Then open:

http://localhost:8000

Check that tasks can be created, marked as complete, deleted and retained after refreshing the page.

To stop the server, press Ctrl + C in its terminal.

Step 12. Create the repository on GitHub

Once the application works locally, we'll save its first version.

We can ask Codex to prepare Git and a .gitignore file, but creating the repository should require our approval.

We could also do it manually:

From the project folder:

git init

Add the files:

git add .

Create the first commit:

git commit -m "Primera version funcional"

And create a private repository on GitHub:

gh repo create mi-primera-app –private –source=. –remote=origin –push

This command creates the remote repository, connects our folder and pushes the initial version.

From then on, GitHub will keep the history of the changes we publish.

Before uploading real code, we must always check that .gitignore excludes sensitive files, credentials and directories that shouldn't be uploaded to version control.

Step 13. Publish the project on Railway

Now we'll check that GitHub can act as the source for our deployed code.

Open the Railway dashboard manually and create a new project.

Select Deploy from GitHub Repo, authorize GitHub if we haven't done so already and choose our repository.

Railway has a build system called Railpack that recognizes static HTML projects.

Therefore, we don't need to ask Codex to generate a Node.js server or a package.json just to publish our small application..

Railway will analyze the repository and prepare the deployment.

If the process fails, we'll check the logs and file structure before changing anything.

Once deployed, go to the service's network settings and generate a public domain.

Open the address in a browser.

If we can see our to-do list working online, we've completed the first deployment.

Step 14. Check that GitHub and Railway are connected

There's still one important test to do.

Seeing the application on Railway proves that we've deployed a version, but we want to make sure that subsequent changes pushed to GitHub are also published correctly..

Return to the project and open Codex:

codex

Ask it:

Add a button to the application that deletes all completed tasks. Keep the current design, check that it works and don't deploy anything. I want to review the changes before saving them to Git.

Test the new feature locally.

Once we've confirmed it works, save the changes:

git add .

git commit -m "Añadir limpieza de tareas completadas"

git push

If Railway's automatic deployment is enabled for that branch, it will detect the new commit and create another version.

Wait for the deployment to finish successfully and reopen the public application.

If the new button appears and works, we've verified the full workflow: Linux > Codex > Git > GitHub > Railway.

This test is much more reliable than simply handing Codex the public URL and asking whether everything is connected.

Step 15. Ask Antigravity for an audit

We now have an application that has been developed and published.

Now, in this test, our second agent comes into play. We're doing it this way to test that everything works, but let me make something clear: with real software rather than a test, the audit takes place BEFORE developing anything and before deploying anything to production.

Open the terminal in the project folder and run:

agy

We'll give it specific instructions:

Act as an independent technical auditor. Review this application and check that it meets its functional requirements. Look for JavaScript bugs, security issues, accessibility problems, responsive design issues and possible failures in local storage. Also examine the repository structure and whether it's properly prepared for Railway. Don't modify any files. Deliver a report ordered by severity, explaining how to reproduce each problem and what solution you propose.

The auditor should review the code and, where possible, run checks. We don't just want it to tell us everything is fine.

If it finds errors, we'll return to Codex, give it the report and ask it to make the necessary fixes.

Then we'll repeat the tests and the audit.

For small projects, one review may be enough. For more important projects, we'll need automated tests and additional checks.

This is what's known as the Loop method..

If we use Claude Code and Codex

The process is the same. Claude Code develops the project and Codex reviews the changes.

We can start Codex and use its interactive review feature:

/review

The specific tool isn't the most important thing. What matters is separating responsibilities and ensuring that the issues identified are real.

With this, we've got our computer ready to build websites, using frameworks such as Astro or even building them from scratch. 

For example, in this article, I explain how to build your business website using this system. Or even your entire online presence on a small budget..

If you look closely, those websites don't use a database, which is why we haven't installed one in this tutorial. If we need one, we can use Convex or Supabase. I'll leave that for another article.

Likewise, you may also want to use this system to develop for WordPress, as I do. In that case, keep reading.

Step 16 (optional). Install LocalWP and prepare it for WordPress

Finally, we'll install LocalWP.

This tool will let us run WordPress on our computer, with a web server, PHP and a database, without having to publish the changes on a live website.

Download the official Linux installer from:

Releases

Select the .deb version compatible with Ubuntu, Debian and Linux Mint.

Once downloaded, we can open it with the graphical installer or run the following from the downloads folder:

sudo apt install ./nombre-del-archivo.deb

Replace the example name with the actual downloaded filename.

Then launch LocalWP from the applications menu and check that it opens correctly.

Next, in this article I explain How to clone a WordPress website with Local WP and here how to optimize it on Windows..

In a later article focused on vibe coding for WordPress, we'll look at the system and workflow I use:

• How I define features.
• How I decide whether to create a plugin or put everything in the child theme's files.
• Which files I put under version control.
• What stays out of GitHub version control.
• How I test.
• How to deploy to hosting that isn't Railway (Webempresa, in my case).

As you can see, there's a lot to cover.

Before wrapping up, here's another tool that may come in handy in certain situations.

Optional: use voice dictation to give instructions

One advantage of working with AI agents is that we can explain features using natural language. That's why dictation tools can be useful.

Personally, I use one when the feature I want is lengthy and it's easier to explain it aloud so that the transcript appears directly in the terminal.

Whisper and tools that run it locally make this kind of dictation possible. On Linux, two options are OpenWhispr or Handy..

It's not essential. You can add it later if you find it useful.

Conclusion: our computer is now ready for vibe coding

That completes the first part of the process.

We have Linux Mint running, Git and Node.js installed, two AI agents available, GitHub connected and Railway ready to publish applications.

Most importantly, we've carried out a full test: generating code with one AI, checking it, pushing it to GitHub, publishing it on Railway and reviewing the result with a second agent.

That's the foundation of the system I want to use.

I'm not trying to replace traditional programming with a series of improvised instructions. The idea is to use AI to develop faster while keeping control of the requirements, versions and results.

In the next article, we'll get to the most interesting part: how to organize a vibe coding project with Linear, define requirements, divide tasks between the analyst-programmer and auditor, and establish a repeatable development process..

Then we'll apply the same system to WordPress using LocalWP, GitHub and Webempresa.

And that's where we'll begin to see how far we can go developing with AI without having to write every line of code ourselves.