FAQ

AI Operator is Peter Kisel's practice and course catalogue about working with AI as an operator: define the work, plan it, delegate it to agents and review the result, instead of just prompting.

The Operator mindset means directing AI through clear definitions, small steps and explicit review instead of steering it by feel in a chat window.

Peter Kisel is the author of AI Operator and The Loop. He has twenty years in tech and builds AI systems, writes about applied AI adoption and speaks at conferences.

The AI Operator course costs 99 euros as a one-time payment with lifetime access.

Available now: the AI Operator course and The Loop. Coming soon: a course on getting things done on a 20 dollar Claude Pro plan, one on cleaning up AI-made messes, and one on taking a vibecoded app to the next level.

A coming-soon course for projects that AI-assisted work left in a state nobody wants to open, about pointing the same tools at the cleanup.

A coming-soon course for solopreneurs who want to build, about a way of working that does not depend on how big your plan is. Module 0 is free forever.

A coming-soon course for an app you vibecoded that people now want to use: how to turn it into a product you can maintain, with the artifacts, roles and standards that stop it falling apart as it grows.

The AI Operator course teaches a complete AI-first workflow: define, plan, delegate and review, so you ship in weeks what used to take months.

Yes. There is no separate interactive mode; you run the same context-loop and next-loop skills in your own session instead of waiting for the scheduled fire.

Yes. Invoke context-loop or next-loop yourself against a specific task when you have review capacity. Each invocation builds exactly one task.

Yes. The port-my-loop skill reads your configured loop, translates the layer that has to change and migrates your existing task files to the new tracker.

Run the entrypoint manually to see the real error, check whether it is a permission prompt stalling an unattended session or a crash, and read Claude's release notes for permission or tool-call changes.

It must not. The loop's skills are written not to read or print .env contents, and any output that includes a secret is treated as a bug to stop and report.

No. The loop fires through Claude Desktop's Scheduled Tasks, so with the app closed or the machine asleep nothing fires and missed runs are not replayed.

Type your answers in the task file below the the-loop:context:end marker and save. One line per question is usually enough.

Open Claude Desktop's Code tab on the repo and ask it to make the pull request mergeable, for example: Please help me make PR 123 mergeable.

Quit Claude Desktop. With the app closed, its Scheduled Tasks do not fire. To make the pause survive a restart, disable both scheduled tasks, context-loop and next-loop.

Edit the cron expression of each scheduled task in Claude Desktop's Code tab, for example 30 9-18 * * 1-5 for context-loop and 0 9-18 * * 1-5 for next-loop to run weekday daytime only.

The stack named directly, where files should go, and what done looks like mechanically, because a new repo has no code for the agent to infer these from.

Find the gap between what the agent had and what it needed, then add that missing signal to what context-loop checks, so the next pass catches it.

In docs/tasks/ inside each repo the loop watches, as plain markdown files. The folder a task is in tells the loop which repo the work belongs to.

Almost always the machine went to sleep, and a sleeping machine does not run scheduled jobs. Claude Desktop's Scheduled Tasks do not wake a suspended computer.

The task scored below the 85 percent readiness gate, so the loop wrote specific questions into the task file rather than guess. That is the gate working as designed.

Check four things in order: the file is in docs/tasks/ of a watched repo, the repo is listed in loop.config.json, the extension is .md, and the status is one the loop picks up.

An empty queue usually means you are out of thought-through tasks, not that something broke. Write the next task as a markdown file in docs/tasks/.

No. The queue is plain markdown files in docs/tasks/ inside your own repos, with no tracker account and no API key.

No. The Loop opens a pull request and stops. You review it and decide whether to merge.

Paste one prompt into Claude Code and Claude installs the loop with you in an install session.

Give it a queue of well-defined tasks, a readiness check before execution, scheduled runs, and a human review of each pull request. The Loop packages exactly that.

You write a task file, a context agent scores it against an 85 percent readiness gate and asks questions until it clears, an execution agent builds it and opens a pull request, and you review it.

Usually 30 to 90 minutes, because the context agent and the execution agent fire half an hour apart.

The Loop costs 29 euros: a founding price for the first 5 buyers, one-time payment, lifetime access, and the loop is yours to keep.

Yes. Module 0 of The Loop, the full walkthrough of how the loop works, is free to read without an email gate.

context-loop scores a task's readiness and asks questions; next-loop builds a task that cleared the gate and opens a pull request. They are the two scheduled skills at the core of The Loop.

Claude Desktop, GitHub and a 20 dollar Claude Pro subscription. The task queue is markdown files in your own repos.

The Loop gives your AI developer a queue of markdown task files and turns them into reviewed pull requests while you are away from the keyboard, at one fire an hour.

The readiness gate is an 85 percent context-completion threshold. A task below it gets questions written back instead of code; a task at or above it can be built.

context-loop runs on Opus 5.5 and next-loop runs on Sonnet 5.5, because scoring ambiguous tasks is a reasoning job and building a well-defined task is a transformation job.

The limit is how many pull requests one person can actually read and judge in a day, so the cadence is set by review capacity, not by how fast the agents can run.

Often no. Vague prompts push the model to cover many interpretations with long output, and output tokens usually cost several times more than input tokens.

It can, if a human approves a destructive step. In Peter's case the model offered a force push with an explicit data-loss warning and he approved it while sleep deprived.

Yes. The Loop runs on Claude Desktop, GitHub and a 20 dollar Claude Pro subscription, and a coming-soon course covers getting things done on that plan.

Write the expectations down before implementation (goal, constraints, acceptance criteria, edge cases), then review the change against that file instead of against your mood.

Peter's Monday planning went from four hours to two with AI, but when the agent broke and he did it by hand in 90 minutes, he realised the savings were never AI's. The subjective win is real anyway.

Peter's view is yes: the perfect equivalent of a bad task is bad code, only faster, so the effort belongs in product judgment and operations.

Usually not. Mid-stream prompting tends to leave half-applied patterns, contradictory constraints and broken invariants. Let the run finish, then review a clean diff.

/unslopify is a Claude Code skill that rewrites AI text against a brand guide, then learns from your edits until the guide is good enough to write without you.

A Slack-native setup of virtual executives that gives you structured disagreement instead of a single polite assistant.

A skill Peter wrote that tears an offer apart without manners. He later turned it into a product, and the part worth building was deciding which criticisms were right.

Treat the model as having a single Post-it Note, not a hard drive: finite space and no version history, so edits pile up beside old ink and add noise instead of replacing it.

Completion measures motion, not whether the work held up or mattered. The gap between motion and verification is where AI adoption breaks.

Not because the model forgets like a person, but because a long thread stops being clean enough to act on without guessing. Keep context short and start fresh from written decisions.

Because AI turns ambiguity into code at high speed. A thin brief gets filled with guesses, and guesses become silent landmines when the system changes later.

Yes. Peter gives conference talks and guests on podcasts about applied AI adoption, drawing on twenty years in tech.

Yes. Teach Me AI Stuff is a set of 1:1 call packages for founders and operators building their own AI systems: bring the hard decision, leave with a system you can run.

The AI Sprint is a fixed price of 5,000 euros for a 1 to 2 week engagement.

Install With Peter is a 450 euro done-for-you add-on where Peter runs The Loop install session for founders who would rather hand it over than do it themselves.

A fixed-price, 1 to 2 week AI Adoption Audit and Roadmap engagement: Peter maps your workflows, surfaces shadow AI your team already runs, sets ROI targets and hands you a 90-day plan.