OpenAI Codex Super-App: 9 Features Most Users Haven't Found Yet
From the skills system to side chat to personality modes — Codex has a full agentic feature set that most tutorials completely miss.
Most Codex Users Are Missing 9 of Its Best Features
OpenAI has been shipping updates to Codex fast enough that even daily users are falling behind. Here are 9 features buried in the current desktop app that most tutorials haven’t covered — starting with the one that changes how you think about the whole tool.
The skills system — global versus project-local markdown recipe files that work across Claude Code, Codex, Cursor, and OpenClaw — is the single most underrated feature in Codex right now. Most people treat Codex like a smarter chat window. The skills system is what makes it a repeatable production tool.
1. Skills: Markdown Recipes That Work Across Every Agent
A skill in Codex is just a markdown file. That’s it. A name, a description, a trigger condition, and a sequence of steps. When you invoke it — either via a /slash command or natural language — Codex reads the file and executes it.
What makes this interesting is where those files live. Global skills go in ~/.codex/skills/. Project-local skills live inside the project directory. The global ones are available in every Codex session you ever open. The local ones are scoped to a single project.
Built like a system. Not vibe-coded.
Remy manages the project — every layer architected, not stitched together at the last second.
Here’s the part most people miss: Claude Code, Cursor, and OpenClaw all read from the same local directory structure. If you build a skill in Codex and store it globally, Claude Code can use it too. You’re not building for one tool — you’re building a shared recipe library that any agent harness can pull from. Nate Herk demonstrated this in a recent walkthrough, showing a morning-coffee.md skill that Claude Code picks up automatically when you ask it to help plan your day.
The practical move: after you build something in Codex that works well, say “turn that into a skill.” Codex will reverse-engineer the workflow into a markdown file and store it globally. Next time, you invoke it with /youtube-comment-insights or whatever you named it, and it runs the same flow consistently. If you want to understand the skill architecture in more depth, the Claude Code skills vs plugins breakdown covers when to build each and how they compose.
2. agents.md — The Project Context File You Should Set Up First
Every new Codex project should start with an agents.md file. This is Codex’s equivalent of Claude Code’s CLAUDE.md — a markdown document that Codex reads at the start of every new chat to orient itself on the project.
Without it, every new chat session starts cold. With it, Codex knows who you are, what the project is trying to accomplish, and what constraints to respect before it writes a single line of code.
The setup is simple: open a new project, ask Codex to read some context about you or your work, then say “create an agents.md file with what you’ve learned.” From that point on, every chat in that project inherits the context. If you’re coming from Claude Code and want to understand how these two context systems compare in practice, there’s a dedicated post on Codex agents.md vs Claude CLAUDE.md worth reading alongside this one.
3. Plan Mode — The Brainstorm Toggle Before You Build
There’s a toggle in the Codex interface called Plan Mode. When it’s on, Codex won’t execute anything. It will only brainstorm, ask clarifying questions, and produce a plan.
This sounds minor. It isn’t. Without Plan Mode, Codex will start writing code the moment you describe a goal. With it, you can iterate on the plan — change scope, add constraints, clarify ambiguities — before a single file gets touched.
The workflow that works: start every new build in Plan Mode, get the plan to a state you’re happy with, then say “submit, implement the plan.” Codex switches into execution mode and works from the agreed spec. Herk’s YouTube analytics demo showed this clearly — he used Plan Mode to nail down the YouTube Data API v3 connection strategy before Codex touched any credentials or wrote any scripts.
4. Full Access vs. Default Permissions
By default, Codex will pause and ask for your approval before doing anything sensitive — network requests, file writes, running scripts. This is the right default when you’re learning the tool.
Once you trust your setup, go to Settings > General > Auto Review and flip it to Full Access. Codex will stop asking for permission and just run. The toggle shows as orange when Full Access is on, which is a reasonable visual reminder that you’ve handed over the wheel.
Not a coding agent. A product manager.
Remy doesn't type the next file. Remy runs the project — manages the agents, coordinates the layers, ships the app.
The practical tradeoff: Full Access is faster but requires that your skills and agents.md are well-specified. Vague instructions plus Full Access is how you end up with unexpected file changes. Tight instructions plus Full Access is how you get genuinely autonomous runs.
5. The Rate Limits Panel (and the Context Window Bar)
Two UI elements that most users scroll past: the rate limits panel and the context window bar.
The rate limits panel is in Settings > Rate Limits Remaining. It shows you two numbers: how much of your 5-hour session you’ve used (resets every 5 hours) and how much of your weekly allotment remains. Both show as percentages. If you’re burning through sessions faster than expected, this is where you diagnose it — usually it means you’ve been running Extra High intelligence on tasks that only need Medium.
The context window bar lives at the bottom of the chat window. It shows what percentage of the current context window is filled. Codex compacts automatically, similar to Claude Code with Opus, but watching this bar tells you when a chat is getting heavy enough that you should consider starting a fresh session or summarizing state into the agents.md file.
One thing Herk noted in his testing: GPT-5.5 is noticeably more token-efficient than Claude’s Opus on both input and output, which is why Codex sessions tend to run longer before hitting limits. That efficiency gap is real and worth factoring into your tool choice for long-running tasks.
6. The Automations Tab — and the GPT-5.2 Trap
The Automations tab lets you set up cron-style scheduled tasks. You define a prompt, a schedule (every Sunday at 5pm, for example), and a model/reasoning setting. Codex runs the task on schedule, inside your project, without you being present.
There’s a bug you need to know about: automations default to GPT-5.2, not GPT-5.5. This is not obvious from the UI. Herk discovered it the hard way when a 40-minute automation stalled — the model was running on 5.2 and couldn’t handle the task load. He stopped it, manually set the model to GPT-5.5 with High reasoning, and the same task completed in 7 minutes.
Every time you create an automation, check the model setting. It will not be what you expect. Set it to 5.5 manually, set the reasoning level (Medium works for most refresh tasks, High for anything involving analysis or code changes), and then let it run. The automation will inject its prompt into a new Codex chat inside your project and execute the full agentic loop.
One important caveat: Codex automations are local cron jobs. If you close the app or shut down your machine, the automation stops. For truly persistent scheduling, you’d need to move the routine to a cloud environment — which is exactly what Claude Code’s cloud routines are designed for. If you’re building multi-agent workflows that need to stay alive, the multi-agent team setup in Paperclip with heartbeat scheduling shows one architecture that handles this.
7. The /slash Command System and @tag References
Typing / in any Codex chat opens a command palette. The full list includes: /goal, /pet, /hatch, /plan, /personality, /browser-use, /skill-creator, /memories, /reasoning, and /model.
A few of these are more useful than they look. /personality lets you toggle between friendly (verbose, conversational) and pragmatic (concise, task-focused, direct). If you’re doing production work, pragmatic is almost always the right setting. /reasoning lets you adjust the intelligence level mid-conversation without going to settings. /model lets you switch between GPT-5.5 and GPT-5.4 on the fly.
The @ system is the other half of this. Typing @ in chat lets you tag specific files or plugins directly into your message. If you want Codex to reference a particular output file, a specific skill, or a connected plugin, @ is how you point at it precisely instead of describing it in natural language and hoping Codex finds the right thing.
8. Side Chat — Parallel Conversations Without Interrupting Your Agent
When Codex is mid-run on something complex, you sometimes have a question that’s adjacent to the task but not part of it. Opening a new chat would interrupt the session. Side Chat solves this.
Click “Open Side Chat” in the top right of any active session. A secondary conversation panel opens. It has access to the same project context — the agents.md, the chat history, the files — but it runs independently. You can ask questions, check on something, or brainstorm a different approach, and then close it when you’re done. The main session keeps running.
This is similar to Claude Code’s / bypass pattern, but more visual. For long-running tasks where you’re multitasking, it’s the right way to stay in the loop without derailing the agent.
9. GPT Image 2 Integration for UI Assets During Builds
Codex has GPT Image 2 baked in. You can invoke it mid-build to generate UI concepts, logos, dashboard mockups, or game assets — and those assets get stored locally in the project directory so subsequent builds can reference them.
In Herk’s YouTube analytics dashboard demo, he asked Codex to use GPT Image 2 to generate a logo (a YouTube play button with comment noise around it) and several dashboard UI concepts before writing any frontend code. Codex generated three visual directions, stored the assets, and then used them as reference when building the actual dashboard components.
This matters because it changes the build sequence. Instead of building a UI and then trying to make it look good, you generate visual concepts first, pick the direction you want, and then build toward that target. The assets are already in the project. The dashboard Herk deployed to Vercel via GitHub had a coherent visual identity because the image generation happened before the code generation, not after.
For builders who want to go from spec to deployed app without managing the image generation step separately, tools like Remy take a related approach: you write an annotated markdown spec, and the full-stack application — TypeScript backend, SQLite database, auth, frontend, deployment — gets compiled from it. The spec is the source of truth; generated assets and code are derived output.
10. The GitHub + Vercel Deployment Pipeline
This one isn’t hidden exactly, but most users don’t realize how tight the integration is. Codex can push directly to a GitHub repository. Vercel watches that repository. When Codex commits a change, Vercel auto-deploys within seconds.
The workflow: build locally in Codex, test on localhost, push to GitHub, watch Vercel deploy to a live URL. If you don’t like the change, you don’t push — the production site never gets touched. If you do push, it’s live in under a minute.
Herk’s demo went from a local dashboard to a live youtube-analytics-demo.app URL in about 30 seconds after the Vercel import. The entire pipeline — Codex writing code, GitHub storing it, Vercel serving it — required no manual deployment steps after the initial setup. For teams building more complex orchestration across multiple agents and models, MindStudio’s visual builder handles the coordination layer: 200+ models, 1,000+ integrations, and a no-code interface for chaining agents and workflows without writing the glue code yourself.
The Feature Most People Will Use Last But Should Use First
The skills system is the answer to the question every Codex user eventually asks: “Why does this feel inconsistent?” It feels inconsistent because you’re not using recipes. You’re improvising every time.
The Claude Code content marketing skill system post shows how this same pattern — build once, invoke repeatedly, improve incrementally — applies across content workflows. The underlying mechanic is identical in Codex. Build a skill from a successful run, store it globally, invoke it next time, update it when you find a better approach.
The builders getting the most out of Codex right now aren’t the ones using the most features. They’re the ones who’ve built the most skills. Every workflow you convert into a markdown recipe is a workflow that gets more reliable over time instead of more frustrating. That’s the actual unlock here — not any single command, but the habit of turning good runs into reusable ones.
The self-improving Claude Code memory system with Obsidian hooks is worth reading if you want to take this further — the same principle of capturing session knowledge and feeding it back into the system applies directly to how you’d evolve a Codex skill library over time.
