Most apps are built once and stay frozen. What if yours got better every time you used it — automatically, without code changes, without retraining a model?
Claude Code, Codex, and AI development harnesses are no longer just for coders — they are becoming essential tools for every job. Sales, customer support, contract management, HR, any process you run on a computer today is being touched by AI harnesses. And Skills — domain-specific instruction sets that shape exactly how AI behaves — are arguably the best improvement AI has seen in months. Skills are the AI Procedure: the cookbook for any business process. But there's a wall none of them have broken through yet.
These tools are extraordinary — but not everything can be done in a chat window or an IDE. Most users and most processes require a better interface and more structure. The AI is ready. The shell it lives in is holding it back.
Not one or the other. A proper native or web app — with your own UI, your own workflows, your own design — running Claude Code in the background as its brain. The intelligence of the harness, the experience of a real product.
Every time you correct an AI decision, that correction is saved. Next run, the AI reads its own history and uses it as examples. No retraining. No data science team. The app just gets better as you use it.
Update the AI's instructions, rules, and reasoning without touching a line of app code. Ship improvements to how Claude thinks daily — while the app itself stays stable and unchanged.
Self-Evolving Apps are web or native applications built on top of Claude Code or Codex — where the AI reasoning layer lives completely outside the app shell, and improves automatically over time.
The app handles the interface, the data, and the user experience. Claude handles the thinking, the matching, the decisions. They communicate through a shared folder — a structured contract that neither side breaks.
Every user correction feeds back as a future example. Every skill update takes effect immediately. The app you ship today is smarter than the one you shipped last week — without a new release.
The app manages the UI, prepares data files, stores corrections, and renders results. It has no embedded intelligence — it is deliberately dumb. Language: Node.js + Express (web) or Swift + SwiftUI (macOS).
The only shared space between the app and Claude. The app prepares it before each run. Claude walks in, reads everything, and leaves a structured answer. Neither side knows about the other's implementation — they only share this folder.
Spawned by the app per session or kept alive between messages. Reads CLAUDE.md for instructions, credentials from .env, corrections.json for past examples. Streams thinking, tool calls, and text deltas back to the app. Writes structured output to result.json.
A folder containing SKILL.md (instructions), Python scripts (preprocessing), and reference documents (domain knowledge, matching rules). Symlinked into four locations so Claude finds it from any context. Update the skill — the next run is smarter. The app never changes.
The app passes input files to Claude. Claude reads the skill instructions, loads domain knowledge, and produces a structured result — streamed live to the UI.
The app parses result.json and shows Claude's decisions in a review interface. Most answers are correct. A few need correction.
You change the wrong answer to the right one. The app saves the correction: which signals were present, what Claude thought, and what the correct answer was.
corrections.json grows. The skill instructs Claude: "Read this file before reasoning. If you see similar signals, use these past answers as authoritative examples."
No model retraining. No data science. Just a casebook that grows with every session — and an AI that reads it before every decision.
For builders who want to understand the implementation. Every pattern is production-tested in a real daily-use application.
Claude streams events line by line. Web apps read via HTTP chunked fetch. Native apps use Swift AsyncStream<ClaudeEvent> — a typed enum covering thinking, toolUse, textDelta, done, and tokenUsage. Every event is rendered live.
All API keys live in references/.env inside the working directory. The app reads and writes this file. Claude reads it directly when calling external APIs. No hardcoded secrets. No app-specific credential stores.
Every skill is symlinked into ~/.claude/skills/, ~/.agents/skills/, ~/workdir/.claude/skills/, and ~/workdir/.agents/skills/. All four point to the same real directory. Update once, all contexts update instantly.
Every run captures input tokens, output tokens, cache read tokens, and total cost in USD from Claude's result event. Displayed after every session. Users always know what processing costs.
Claude never returns freeform text as primary output. Every run ends with a structured JSON envelope: {"message":"...","results":[...]}. The schema is the only hard coupling between app and skill. Change the skill freely — keep the schema stable.
Native apps keep one Claude process alive per session via stdin/stdout — eliminating per-message startup delay. Web apps spawn per message. Both patterns supported. Both share the same working directory and skill architecture.
skills/ dir, symlinked into workdir--session-id / -r flagsAsyncStream<ClaudeEvent> enum — no JSON in view layerSkillManagerEnvStore — reads references/.envWe're sharing the architecture, the patterns, and the lessons from building in production. If you're building AI tools that need to go beyond the chat window — let's talk.
The full headless app creator skill — patterns, prompts, and architecture — packaged and ready to drop into your own Claude Code setup.