The Studio

One human CEO.
Ten AI departments.

An AI studio organised like a software company. Each department has its own skills, its own work queue, and only the context it actually needs.

Built like a company

One person decides. One desk keeps the day in order. Ten departments of specialists do the work.

  1. 1

    The CEO

    One human. Answers the questions, reviews every mock, approves every gate.

  2. 1

    Chief of Staff

    Routes every new issue to the right department, keeps the day in order, and sets up each new product's repository and folder.

  3. 10

    Department heads

    Ideation to Marketing. Each head plans the work and asks the CEO.

  4. 46

    Specialists

    Claude sub-agents, each on the model that fits its job.

  5. 69

    Skills

    All the studio's written playbooks: how each head and specialist does the work.

  6. 11

    Outside tools

    Godot, ComfyUI, Fastlane, Firebase and more: what a department would otherwise buy in.

01 · Context

Agentic codingUnrelated work piles up in one context window. The model weighs all of it, so the output turns erratic: tasks get mixed together and it fixes problems that no longer exist.

The hard part was never the code. It was the context.

The studio keeps context outside the model. GitHub issues hold the work, written handoffs carry the decisions, and each department loads only its own brief. Every session starts clean.

One giant assistant

Unrelated context in, erratic output out.

Context window94% full

Ten departments

Each one starts from its own brief and holds only what its job needs.

Ten windows, each mostly emptyDesign is working on the chest tile

  1. IssuesThe work and every decision live on GitHub, not in a chat that disappears.
  2. HandoffsA short written brief passes to the next department instead of a whole transcript.
  3. DepartmentsEach one sees only its own queue, skills and brief, so nothing unrelated gets in.

02 · Issues, not chat

Agentic codingThe work lives in a chat. Close it and the plan, the decisions and the reasons go with it.

Every piece of work is a GitHub issue.

Labels say who owns it, who needs to know and what is waiting on the CEO. Departments ask each other through sub-issues. Every decision is a comment, so the issue is the memory.

dept:
One owner. The label decides which department's queue it joins.
fyi:
Who needs to know. They hear about it without loading anything.
prio:
What gets picked first when the CEO chooses who works today.
ceo:review
Waiting on the CEO. Nothing moves until it's answered.
sub-issue
One department asking another, tracked like any other work.

03 · Departments and heads

Agentic codingOne agent wears every hat: it designs, codes, tests and markets with the same instructions.

Each department owns its work. Its head runs the specialists.

A label routes the issue to one department. Its head plans the work, asks the CEO and hands each part to a specialist. Only that department's skills load, never all 69.

Loaded for this issueTold about it, loads nothingStays on the shelf

    5of 69 loaded

    04 · Short skills

    Agentic codingGiant prompts and rule files load every time, whether the task needs them or not.

    Every skill is short. The detail waits until a step needs it.

    A skill is a one-page procedure. Its depth lives in reference files that load only when that step runs. A check runs after every skill edit, so none of them can quietly grow.

    • accessibility.md
    • anti-patterns.md
    • components-android.md
    • components-ios.md
    • directions.md loaded for step 3
    • platforms.md
    • screen-states.md
    • tokens.md
    • quick-mock.md
    lines in a skill, on average
    49
    lines of reference, read only on demand
    6,158
    lines before the budget check fails a skill
    500

    05 · Small handoffs

    Agentic codingThe next task starts by inheriting the last task's entire conversation.

    The next department gets a brief, not a transcript.

    Every handoff is written back to the GitHub issue. The next department starts clean from that brief, instead of inheriting a massive conversation.

    06 · Approve before build

    Agentic codingIt builds first and asks later, so you find out what it misunderstood after it has written it.

    Nothing gets built until the CEO says yes.

    Before any work starts, the department either asks its questions or shows a prototype. Either way, the work waits on one person.

    The ceo:review label holds the issue until the CEO answers.

    07 · Borrowed expertise

    Agentic codingIt only knows what the model knows, so the result looks like every other AI app.

    The best public skills and tools, hired in like specialists.

    Where someone has already written the best guide to a craft, the studio uses it instead of writing its own. Each one is loaded by the department that needs it, and nowhere else.

    • taste-skillDesign · art direction for screens and sites
    • frontend-designDesign · Anthropic's guide to distinctive interfaces
    • UI/UX Pro MaxDesign · patterns, palettes and type pairings
    • Slop.mdDesign · the list of tells that make work look AI-made
    • Material 3Design and Engineering · Android, done the platform's way
    • Liquid GlassDesign and Engineering · iPhone, done the platform's way
    • GodotGame mechanics · the game engine
    • ComfyUIDesign · painted art from approved placeholders
    • FastlanePublishing · builds and store uploads
    • FirebaseEngineering and Publishing · services and hosting

    08 · Rules that can't be forgotten

    Agentic codingAn instruction in the prompt gets forgotten halfway through, and nothing notices.

    The rules that matter are enforced, not requested.

    Hooks run on every action, whether the agent remembers the rule or not. Checks have to pass before the CEO is ever asked.

    1. Session startAfter a clear, the last handoff loads by itself, so work resumes without rereading everything.
    2. Design gateA restyle can't reach a phone or a pull request until its visual audit and an independent review pass.
    3. Skill budgetEvery skill edit is measured. Too long, and the change is refused.
    4. Quality loopBuild, tests, lint and review all pass before anyone asks the CEO.
    5. Protected branchesNothing is pushed straight to the main or development branch. Every change is a pull request the CEO merges.
    6. Build ledgerAfter every turn, time, tokens and skills used are written down.

    09 · Chief of staff, continue

    Agentic codingYou are the scheduler. Every morning starts from scratch, steering turn by turn.

    The next morning is one command.

    The CEO doesn't brief ten departments. The Chief of Staff reads the latest handoffs, checks GitHub, asks anything it needs, and keeps the work moving. Every session ends clean.

    1. Start with the Chief of Staff

      It routes new issues, then asks the CEO everything waiting on them, one multiple-choice question at a time.

    2. The CEO picks the departments

      One question: which departments work this session. The busiest unblocked queue is recommended, or run every department with work, in order.

    3. Each head works in turn

      The chosen heads run one after another on their own queues. Between heads, the Chief of Staff writes down where things stand.

    4. Clear and start again

      With the handoff saved, the CEO clears the conversation and starts fresh through the Chief of Staff. Every session begins clean, and nothing is lost.

    Not agentic programming. A company.

    Agentic programming
    A studio built like a company
    The unit of work is a prompt to a coding agent.
    The unit of work is an issue, owned by a department.
    A developer steers the agent, turn by turn.
    The CEO makes the decisions. The Chief of Staff and the heads run the work.
    It writes code.
    It builds the whole product: idea, design, art, balance, marketing and release.
    It knows what the model knows, plus the prompt.
    Every role has written skills, the way a company writes down how each department works.
    Its memory is one conversation that fills up and drifts.
    Its memory is handoffs and GitHub, so every session starts clean.

    10 · The right model for each role

    Agentic codingOne model for everything: too costly for routine work, not careful enough for the hard calls.

    Every role is staffed with the model it needs.

    Like hiring, each seat in the company is matched to the work. The expensive judgement is saved for where it pays.

    • OpusHeads and hard callsPlanning, architecture, design direction, reviews.
    • FableRare spikesEngine spikes, balance campaigns, milestone plans, escalations.
    • SonnetSpecialistsBuilding, writing listings, posts and store assets.
    • HaikuRoutine desksRouting, digests, lint, translations.

    The outcome

    Real footage from the game in development, recorded straight from the build.

    From people using it

    Less context. More projects at once.

    “The aiceo tools and workflows are redefining AI development. By pulling everything into GitHub, it's easier and faster to plan and work on my projects, and it's made it possible to actively work on several at once without blowing up my usage limits.”

    Jared ChaytorUses aiceo

    “Most AI setups drag the whole company into every task, and you pay for it in tokens. aiceo only sends the department whose job it actually is, with the few rules that matter right now. Everything lives on GitHub issues, so a session reads one issue instead of relearning the whole project.”

    Zane RastrickUses aiceo

    So far

    What it has made so far.

    • 69written skills
    • 14plugins
    • 8apps
    • 3apps live on Google Play
    • 2apps live on the App Store
    • 4apps in store testing
    • 1,648issues and pull requests since 15 Oct
    • 858pull requests merged
    • 531issues closed
    • 1,732commits

    None of this is new. People have organised teams this way for decades.

    It turns out the same structure works remarkably well for AI agents too.