If You Haven’t Installed These 3 Skills, Your Codex Is Only Half as Useful

If you’re still using Codex by “submitting a request → waiting for it to write code → opening the webpage to check it yourself,” that’s really not very smart.

I rechecked the recently popular Codex Skills.

The top three worth trying are:

agent-browser

planning-with-files

karpathy-guidelines

First, let me clarify:

These are all third-party community tools—not official built-in Skills from OpenAI.

There’s also no credible benchmark to support the claim that “Codex performance doubles after installation.”

What they truly supplement is:

agent-browser
→ Browser execution

planning-with-files
→ State management for long tasks

karpathy-guidelines
→ Constraining coding behavior

Codex itself already supports Agent Skills. A Skill must include at least a SKILL.md file and can also include additional resources like scripts, references, and assets, making a workflow reusable.

01 | agent-browser: Let Codex Verify Itself by Opening a Webpage After Writing Code

First up:

agent-browser

This is an open-source browser automation CLI from Vercel Labs. Its official documentation explicitly states it can be used with:

Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode, and other agents.

It can:

Open a webpage
↓
Read page elements
↓
Click buttons
↓
Fill forms
↓
Take screenshots
↓
Scrape information
↓
Recheck page states

The most practical use isn’t letting Codex:

Open Google for me.

But rather:

Having Codex verify its own work on web features after writing them.

For example, you just asked it to build a login page.

You can then directly continue:

Use agent-browser to test http://localhost:3000/login. Test empty password, wrong password, and correct credentials separately. Check error messages, page redirects, and final login status. Save screenshots for failed scenarios. Don’t modify data outside the test account.

Then Codex can go through:

Writing code
↓
Starting the project
↓
Opening the webpage
↓
Filling in credentials
↓
Clicking login
↓
Checking results
↓
Finding issues
↓
Fixing
↓
Retesting

The typical workflow with agent-browser is to first run:

agent-browser snapshot -i

to get interactive elements like buttons, input boxes, and links, with references like @e1, @e2, then perform:

agent-browser click @e1
agent-browser fill @e2 "hello"

After the page changes, take a new snapshot.

A coding agent truly becomes useful not just because it can write code, but because it starts verifying its own output.

Installation

The current official recommended way to install agent-browser globally:

npm install -g agent-browser
agent-browser install

The second command downloads Chrome for Testing.

Then install the corresponding Skill for the coding agent:

npx skills add vercel-labs/agent-browser

This is also the recommended method from the agent-browser team for Codex, Claude Code, Cursor, and other agents.

02 | planning-with-files: An “External Working Memory” for Complex Tasks

Second:

planning-with-files

It solves a very real problem for coding agents:

The longer the task runs, the more likely the original goal gets pushed out of context.

For example, you ask Codex:

Add a complete permission system to the project.

At first, it’s clear.

Then it starts:

Analyzing the database
↓
Modifying the schema
↓
Writing APIs
↓
Updating the frontend
↓
Fixing tests
↓
Debugging
↓
Adjusting configurations

After dozens of tool calls, it can easily:

Re-investigate things already confirmed;
Repeat mistakes made earlier;
Drift away from the original requirements.

The approach of planning-with-files is straightforward:

Don’t keep all important state in the model context—write it to files.

It maintains three core Markdown files:

task_plan.md
→ Goals, phases, next steps

findings.md
→ Research results, key discoveries, decisions

progress.md
→ What’s been done, test results, error logs

The project’s author even explains this design using:

Context Window = RAM

Filesystem = Disk

So even if the task spans a long session, involves context compression, or you re-enter the project, the agent can first read the files to restore its working state.

Installation

The project’s README currently provides this method for Agent Skills users:

npx skills add OthmanAdi/planning-with-files --skill planning-with-files -g

The project explicitly lists Codex support.

After installation, you can tell Codex directly:

Use planning-with-files to complete this task. First create a task plan, then start implementation. Write important findings to findings.md. Update progress.md and task_plan.md after completing each phase.

03 | Karpathy Guidelines: Prevent Codex from Writing Wildly

Third:

karpathy-guidelines

This Skill does something entirely different.

It doesn’t provide a browser.

It doesn’t provide a database.

It only handles one thing:

Constraining the coding agent’s behavior.

Many people have used Codex and encountered:

I asked you to fix a button, why did you refactor the entire component?

Or:

I just asked you to fix a bug, why did you add several abstract layers I didn’t request?

Karpathy Guidelines addresses exactly this kind of problem.

But first, let me correct an important piece of information:

This is not an official Codex Skill created or released by Andrej Karpathy.

The community Skill’s own description states:

It is a set of behavioral guidelines compiled from Andrej Karpathy’s public observations on common problems in LLM coding.

The core consists of four principles.

1. Think Before Coding
   Get it clear before you start writing.
   If there’s ambiguity, don’t silently make decisions for the user.
   Clarify first:
   What is the goal?
   What are the assumptions?
   Are there multiple interpretations?
   Is there a simpler solution?

2. Simplicity First
   Write only the code needed to solve the current problem.
   If 50 lines will do:
   Don’t create a 200-line framework for so-called “future extensibility.”

3. Surgical Changes
   This is especially practical.
   Only change what’s necessary to complete the task.
   For example, if the user asks you to modify:
   LoginForm.tsx
   Don’t casually:
   Refactor the entire auth system
   Change the CSS architecture
   Rename a dozen variables
   Add three helper classes

Every change should be able to answer:

How does this relate to the current requirement?

4. Goal-Driven Execution
   Transform:

Fix this bug.
Into:
First reproduce the problem
↓
Establish verifiable conditions
↓
Make changes
↓
Run tests
↓
Confirm the bug is gone
↓
Confirm related features haven’t regressed

The better the agent can define “what done means,” the less likely it will write a ton of code without actually solving the problem.

Installation

Currently provided by skills.sh:

npx skills add https://github.com/multica-ai/andrej-karpathy-skills --skill karpathy-guidelines

The corresponding Skill already includes the Skill metadata needed for Codex use.

After installation, you can explicitly tell Codex:

Use karpathy-guidelines to fix this bug. Only modify the files necessary for the task. Don’t refactor casually. Don’t add features not requested. First reproduce the problem, then modify and run related tests to verify.

04 | Using All Three Together Is Where It Gets Really Interesting

They actually control different stages:

planning-with-files
↓
First manage complex tasks

karpathy-guidelines
↓
Don’t expand requirements wildly during coding

agent-browser
↓
Finally verify on a real webpage

This forms:

Requirements
↓
Planning
↓
Coding
↓
Tests
↓
Browser verification
↓
Record results

For example, you’re preparing to:

Add email registration to a SaaS app.

You can directly tell Codex:

Use planning-with-files and karpathy-guidelines to complete this task. Goal: Add email registration. First phase: only analyze the project and create a plan, no code. Success criteria:
Normal email can register;
Duplicate email is rejected;
Invalid email cannot submit;
After registration, enter Dashboard;
All new tests and existing related tests pass. Only modify necessary files during changes, no casual refactoring. After completion, use agent-browser to actually complete one successful registration and two failure cases on the local page. Finally, record test results and outstanding issues.

At this point, Codex’s workflow becomes more like:

Read the project
↓
Plan
↓
Implement
↓
Test
↓
Open the webpage
↓
Click for real
↓
Find issues
↓
Fix
↓
Re-verify

Rather than:

Code has been generated. Please test it yourself.

05 | Not All Tasks Need All Three Skills

If it’s just:

Changing a color
Fixing a typo
Explaining a function
Writing a regex

There’s absolutely no need to activate complex planning.

These three skills are more suitable for:

agent-browser
Web projects, E2E, forms, backend systems, browser automation.

planning-with-files
Complex research, tasks with 3+ phases, heavy tool calls, work that may span long sessions.
The project itself also primarily positions it for long tasks like this.

karpathy-guidelines
Debugging, maintaining legacy projects, partial modifications, refactoring, and tasks where you’re most worried about the agent “modifying more and more.”
It also explicitly reminds:
These guidelines lean cautious—don’t mechanically apply them to simple tasks.

06 | One Last Tip: Don’t Blindly Install Third-Party Skills

This point I think is more important than recommending which three to use.

A Codex Skill doesn’t necessarily consist of just one Markdown file.

OpenAI’s current Skill specification allows including:

SKILL.md
scripts/
references/
assets/

Among them, scripts/ can contain actually executable Python, Bash, and other code.

So before installing a third-party Skill, at least look at:

SKILL.md
scripts/
Hooks
Which external tools it calls
What commands it will execute

A Skill essentially expands the agent’s capability boundary, so installing a Skill is not the same as installing a regular prompt.

Especially those involving:

Browser control;
File modification;
Shell;
Hooks;
Account login;
External APIs;

Check the source code first, then decide whether to enable it long-term.

Final Thoughts

Many people’s first reaction to using Codex is:

Switch to a more powerful model.

But after working on large projects, you’ll realize:

The model is only part of it.

A coding agent also needs:

Tasks not to go off track.
Code not to be modified wildly.
Results that can be self-verified.

These three skills correspond exactly to:

planning-with-files: Managing complex tasks.
karpathy-guidelines: Controlling engineering behavior.
agent-browser: Completing real webpage verification.