jeo-code: The Harness Engine That Makes You a 10× AI Builder

🤔 Curiosity: What If Your Coding Agent Came with Its Own Skill Tree?

Eight years shipping AI games at NC SOFT and COM2US taught me one thing: the bottleneck is never raw intelligence — it’s the harness, the scaffolding, guardrails, and feedback loops that make intelligence usable in a real repo. OpenAI’s Codex experiment proved it: a 1M-line codebase with zero human-written code, where the heroes weren’t the model weights but the harness engineers.

That question stuck with me: What if the harness itself was the product?

Enter jeo-code — and its companion jeo-skills.

Curiosity: Can a coding agent with a built-in skill tree make any developer 10× more productive than one using raw LLM APIs?

---

📚 Retrieve: What Is jeo-code?

jeo-code (jeo on the CLI) is a pure-TypeScript AI coding agent that runs on Bun (≥ 1.3.14) with zero native dependencies. It features a Spec-first workflow, deep-interview Socratic capabilities, robust TUI with TMA (tmux) integrations, and native Ouroboros compatibility. You run it inside any repository, and it reads files, edits them, executes commands, and drives tasks to completion.

Its standout feature is the gjc-style flat inline stack TUI: completed work flushes into scrollback as glyph-led ledger lines and bordered tool cards, avoiding scrollback flooding and allowing terminal mouse-wheel scrolling mid-turn. It also supports seamless clipboard image paste (Ctrl+V) across macOS and Linux, sending images as true multimodal input on every provider.

But the design philosophy is what sets it apart.

The Five Harness Principles Baked In

Principle	What It Means	Why It Matters
Spec-First	deep-interview Socratic gate before any code	No wasted cycles on ambiguous tasks
Reviewed Plans	ralplan critic subagent whose [OKAY] is persisted and required	Real consensus, not theater
Gated Execution	jeo approve blocks until you explicitly confirm	You stay in control
Honest Verification	ultragoal runs real suites — never fabricates per-criterion passes	Trust the output
Self-Correcting Loop	Post-edit hooks (tsc/eslint/tests) feed diagnostics back to the agent	Bugs fixed in-loop

Multi-Provider, One Loop

One agent loop, every major LLM. Switch providers with /provider login <name> from the input box — the choice persists as the new default.

The TUI That Doesn’t Get in Your Way

jeo                                    # interactive agent in your repo
jeo "refactor auth module + run tests" # one-shot
jeo --tmux                             # isolated tmux session
jeo doctor                             # check config + model connection

Action	Shortcut
Slash command palette	/ + Tab
Run a skill workflow	$<skill> [intent]
Direct shell command	!<command>
Recall previous queries	↑ / ↓ (persisted in .jeo/input-history)
Expand last response	Ctrl+O
Paste clipboard image	Ctrl+V

---

📺 See It In Action

Here is the official demo of jeo-code in the wild — watch the agent interview, plan, execute, and verify a real coding task:

Full demo and install guide → docs/usage-guide.md

And here is the Remotion-animated promo rendered as React code for this post — 4 scenes, 300 frames at 30fps, 1920×1080:

The Remotion source lives at tools/jeo-promo-video/src/JeoPromo.tsx in this blog’s repo.

---

🚀 Where It Gets Powerful: jeo-skills

The harness engine alone is powerful. With jeo-skills, it becomes genuinely formidable.

⭐ Star jeo-skills on GitHub →

jeo-skills is a curated collection of 146 installable skill folders for LLM-based development workflows. Each skill is a SKILL.md that tells the agent exactly which tools to use, which patterns to apply, and which route-outs to respect — so the agent stops guessing and starts shipping.

Install Any Skill in One Command

# Install a specific skill
npx skills add https://github.com/akillness/jeo-skills --skill scrapling

# Install the whole library at once
git clone https://github.com/akillness/jeo-skills.git && bash jeo-skills/install.sh

The Skill Ecosystem Map

146 Skills Across Every Domain

Category	Skills (sample)	Count
🏗️ Orchestration	ooo, bmad, plannotator, team, ultrawork, autopilot	12
🔬 Research	deep-dive, llm-wiki, autoresearch, graphify, scrapling	9
⚙️ Dev Workflow	tdd, debugging, code-review, git-workflow, spec-kit	18
🎬 Media & Visual	remotion-video-production, god-tibo-imagen, slides-grab	8
🎮 Game Dev	unity-gamedev-skill-pack, game-performance-profiler, game-ci-cd-pipeline	6
☁️ Platform	firebase-ai-logic, supabase-agent-skills, vercel-deploy, genkit	11
🤖 AI Agents	crewai-multi-agent, openai-agents-python, pydantic-ai, clawteam	14
📊 Data & Analytics	data-analysis, looker-studio-bigquery, langsmith, opik	9
🔒 Quality & Security	ultraqa, security-best-practices, backend-testing, web-accessibility	12
… and more	okf, obsidian, compresso, rtk, semble, graphify	47
Total		146

---

💡 Innovation: Becoming a 10× AI Builder

The real insight isn’t “jeo runs your AI.” The insight is what changes about how you think when you have a trustworthy harness.

The Builder’s Flywheel

Use Cases

🎮 Use Case 1: Game Feature Development

Scenario: Ship a new procedural level system for a mobile RPG.

jeo "design and implement a wave-function-collapse dungeon generator
     using existing TileMap class, integrate with GameManager, test on device spec"

What happens:

1. deep-interview asks 8 clarifying questions (tile types? seeding strategy? fallback for impossible states?)
2. ralplan generates a 3-phase blueprint, critic subagent signs off with [OKAY]
3. jeo approve gates until you read and confirm
4. team spawns executor subagents: one for WFC algorithm, one for GameManager integration, one for unit tests
5. Post-edit hook runs tsc && jest --coverage, errors fed back to the agent, fixed in-loop
6. ultragoal verifies all acceptance criteria against real suite output

With unity-gamedev-skill-pack: The agent knows Unity’s project structure, avoids serialization pitfalls, and cites the Unity docs it’s working from.

🔬 Use Case 2: Research → Production Pipeline

Scenario: Implement a RAG-based player-support bot from a recent paper.

jeo "$deep-dive implement context-aware retrieval system from arxiv 2506.xxxxx
     for our player support knowledge base"

What happens:

1. deep-dive activates — traces causal hypotheses, crystallizes requirements
2. llm-wiki captures findings into ~/vaults/llm-wiki/ for durable memory
3. graphify builds a knowledge graph of the system architecture
4. scrapling fetches and parses the arxiv paper + related GitHub repos
5. ralplan blueprints the implementation with honest tradeoff tables
6. team builds the retrieval layer, embedding pipeline, and eval harness

Time saved: What takes a 2-person team 2 weeks, jeo handles in hours — with citations.

🎬 Use Case 3: Marketing Content at Code Speed

Scenario: Generate a promotional video + blog post for a new AI feature launch.

jeo "create a Remotion promo video + blog post for our new matchmaking AI feature"

What happens:

1. remotion-video-production skill activates — plans scenes, animation budget, asset list
2. god-tibo-imagen generates missing hero images via Codex backend (no extra API key)
3. Remotion compositions rendered at 1920×1080 as MP4
4. Blog post authored with crisp SVG workflow diagrams, embedded video, GitHub links
5. vercel-deploy or Jekyll build deploys the post

This very post you’re reading was built exactly this way. 🎉

The Compounding Effect

Without jeo	With jeo + jeo-skills
Write prompts, iterate blindly	deep-interview crystallizes requirements first
Hope the agent doesn’t hallucinate	ralplan critic + [OKAY] gate blocks bad plans
Manually run tests after each change	Self-correcting hook loop — agent fixes its own bugs
Start from scratch each session	.jeo/ state persists, /resume continues any task
One model, one provider	Switch Anthropic → OpenAI → Ollama mid-task
General-purpose agent guesses	146 skills encode exactly what experts do

---

🏗️ Architecture Deep Dive

The jeo-skills architecture diagram shows how skills, harnesses, and the jeo loop interconnect:

How a Skill Execution Works

Every skill is routing-first: picks the lightest workable path, routes out honestly if scope is exceeded. No over-promising. No silent failures.

---

📦 Installation & Quick Start

Method 1 — Bun (recommended, fastest startup)

# Install Bun runtime
curl -fsSL https://bun.sh/install | bash

# Install jeo-code globally
bun install -g jeo-code

# Verify
jeo --version

Method 2 — npm (universal Node.js)

# Install globally (requires Node.js 18+)
npm install -g jeo-code

# Or run once without installing
npx jeo-code

Connect Your LLM Provider (required)

jeo-code supports every major LLM. Run jeo doctor first to see connection status, then log in to your preferred provider:

# Diagnose connection status
jeo doctor

# Anthropic (Claude)
jeo /provider login anthropic
# → prompts for ANTHROPIC_API_KEY

# OpenAI (GPT / Codex)
jeo /provider login openai
# → prompts for OPENAI_API_KEY

# Ollama (local, free — no API key needed)
ollama serve          # in a separate terminal
jeo /provider login ollama

Tip: /provider login <name> also works from inside the jeo interactive TUI — no need to restart.

Install All 146 jeo-skills

The fastest way — let your LLM agent install them for you. Hand this prompt file to any agent (jeo, Claude Code, Codex, Cursor…) — it reads the instructions and installs every skill automatically:

⭐ RECOMMENDED — ONE-LINE AGENT INSTALL

# Send to your LLM agent — it will read and install automatically
curl -s https://raw.githubusercontent.com/akillness/jeo-skills/main/setup-all-skills-prompt.md

Prefer to do it by hand? The classic clone-and-run path still works:

# Manual full install
git clone https://github.com/akillness/jeo-skills.git
cd jeo-skills && bash install.sh
# → creates 146 skill folders in ~/.agents/skills/

# Verify
ls ~/.agents/skills/ | wc -l   # → 146

Run jeo

# Interactive mode
jeo

# One-shot with a skill prefix
jeo "$deep-dive explain the architecture then refactor the auth module"

# Check your skill library
ls ~/.agents/skills/ | wc -l   # → 146

---

📊 Performance Comparison

Approach	Setup Time	Iteration Speed	Verification	Resume After Crash	Skills
Raw LLM API	0 min	Slow (manual)	❌ Manual	❌	❌
Generic coding agent	5 min	Medium	⚠️ Optional	⚠️	❌
Claude Code / Codex	10 min	Fast	⚠️ Hook only	✅	❌
jeo-code	10 min	Fast	✅ Honest	✅	⚠️ Manual
jeo-code + jeo-skills	15 min	🚀 10× Faster	✅ Honest	✅	✅ 146 skills

The skills layer is what changes the multiplier from 3× to 10×. The agent stops guessing the right approach and follows proven, tested patterns.

---

🧠 Hard-Won Lessons: 8 Years of Production AI

Building production AI for millions of game players taught me three things about agentic systems:

1. Gates beat guidelines. Telling an agent “be careful” does nothing. A gate that blocks done until ultragoal passes — that’s a mechanical constraint that actually works.

2. Skills encode institutional knowledge. Each skill in jeo-skills is a distilled answer to “what does an expert do when they encounter this?” Agents with skills don’t reinvent — they apply. The difference is the same as a junior developer Googling vs a senior who already knows the answer.

3. The harness compounds. The first week with jeo is about speed. The second week is about consistency. By the third week, you’ve stopped thinking about how to use the agent and started thinking about what to build. That mental shift is the real 10× multiplier.

New Questions This Raises

• Can we auto-generate new skills by having jeo observe expert developers in real sessions?
• What does a “skill marketplace” look like — where game studios share domain-specific harnesses?
• How do we benchmark skill quality? Is ultragoal the right metric, or do we need skill-specific eval harnesses?

---

⭐ Star the Projects

Both repos are open source and actively maintained:

⭐ akillness/jeo-code

Bun-based AI coding agent · spec-first · real gates · honest verification

bun install -g jeo-code

🚀 akillness/jeo-skills

146 skills for LLM workflows · TOON format · Claude / Codex / Ollama

npx skills add https://github.com/akillness/jeo-skills --skill <name>

---

🎮 Meet the jeo Character

The jeo mascot is the embodiment of the harness philosophy — methodical, precise, and always honest about what it knows. When jeo says [OKAY], it means it.

Built with Bun. Powered by every major LLM. Extended by 146 battle-tested skills.

This is what being a 10× AI builder actually looks like.

---

References

Projects:

• jeo-code — GitHub Repository
• jeo-skills — GitHub Repository
• jeo-code Usage Guide
• jeo-skills CHANGELOG

Harness Engineering:

• Harness Engineering: The 5 Rules That Let Agents Ship 1M Lines
• CLI Harness for Coding Agents
• Reliable Agent Systems

Tools Used in This Post:

• Remotion v4 — code-first video production from React components
• god-tibo-imagen — AI image generation via Codex backend
• Scrapling — adaptive web scraping (used to fetch jeo-code repo data)
• Bun runtime — fast JavaScript/TypeScript runtime