Each test runs the skill then is graded independently; the throttle case fails for giving a single definitive diagnosis
The repair loop rewrites SKILL.md, shows a before/after diff, all tests pass — then export the skill as a ZIP.
Two to three input/output pairs demonstrate the workflow, including a seller claiming the car "only needs a throttle adjustment.
Two to three input/output pairs demonstrate the workflow, including a seller claiming the car "only needs a throttle adjustment.
GPT-5.6 compiles the workflow into a structured bundle: SKILL.md, examples/, tests/, README.md — with static validation passing.

OneRun — Turn a successful AI workflow into a tested, portable Codex Skill

I got tired of losing my best AI workflows inside closed browser tabs. I’d build something awesome in a chat session, close the tab, and poof—it was gone. I built OneRun to fix that. It takes a single successful run and turns it into a tested, reusable skill you can actually keep and share.

What it actually does

Give OneRun a description of a workflow and two or three examples, and it packages it into a portable Codex Skill. It compiles the skill into real files (SKILL.md, examples, tests, a README), runs automated tests on it, grades the output, and even repairs the skill if something breaks. Once it passes, you just export it as a ZIP.

To show how it works, I built a Used Car Listing Risk Analyzer demo. It parses car ads and separates hard facts from seller hype, buyer observations, and potential red flags. For example, if a seller claims a car "just needs a minor throttle adjustment," but the symptoms point to three different mechanical issues, OneRun knows the correct answer isn't to take the seller's word for it—it’s to flag the risks and recommend specific tests.

The Live Demo uses a fast, deterministic mock mode so anyone can click through the pipeline instantly.
The Demo Video shows the real GPT-5.6 engine doing the actual heavy lifting in real time.

How it’s built

The stack is Next.js, TypeScript, and Tailwind CSS.

Under the hood, GPT-5.6 handles the complex logic via the OpenAI Responses API using structured outputs. I used Zod schemas to define every data structure and validate model responses.

I made a point to keep AI out of the deterministic stuff: slug generation, file paths, validation, ZIP archiving, and scoring are all handled by standard, tested code. Every OpenAI call is isolated behind a single module, which made it easy to build a mock mode for keyless demos and automated testing.

57 unit tests
1 Playwright end-to-end test for the full happy path (with mocked AI)
Built with Codex acting as my primary software engineer throughout the project.

The hard parts (and how I solved them)

Bulletproof Keyless Demos: Building a demo that works reliably without an API key was tricky. By isolating the AI layer, the mock mode can even intentionally fail a test to demonstrate the auto-repair loop in a real, reproducible way.
Safety & Honest Feedback: Generated file paths are strictly sanitized, and the app refuses to package a skill if validation fails. I also made sure to explicitly separate static validation from model-graded evaluation so the user always knows exactly how a test passed.
Bleeding-Edge Stack: Working with brand-new releases (Next 16, Zod 4, Tailwind 4) meant spending quality time in the docs rather than relying on muscle memory.
Handling Latency: Real GPT-5.6 compilations take roughly 70 seconds. Instead of letting the UI hang indefinitely, I built proper timeout handling and state tracking.

What I’m proud of

The full happy path works end-to-end on real GPT-5.6, passing type checks, linting, all 57 unit tests, the build process, and the E2E test.

Most importantly, the repair loop isn't a trick. It generates real diffs and genuinely turns failing skills into passing ones. The five-stage pipeline makes the compilation process visible instead of hiding everything inside a black-box chat window.

Key Takeaways

Treating AI workflows like code compilation just works. The Extract $\rightarrow$ Test $\rightarrow$ Repair $\rightarrow$ Export pipeline brings standard software engineering discipline to prompt engineering. Using a separate model instance to grade outputs proved far more reliable than asking a model to grade its own work.