Ship your first change with 100xprompt in about five minutes. You launch it inside a project, connect a model, hand it a task, and watch it plan the work, edit files, and verify the result - approving every consequential action as it goes.
You need 100xprompt installed and a project you can safely experiment in. A git repository is ideal, so you can review and roll back changes. If you don’t have it installed yet, start with the installation page.

​
Understand the first-run rhythm

Every task follows the same rhythm. 100xprompt plans what it’s going to do, edits files and runs commands to make it happen, then verifies the result - pausing for your approval whenever it wants to touch something that matters.

​
Ship your first change

Suppose you want to add a small feature to a project and see the full loop end to end. Follow these steps.
1

Launch 100xprompt in your project

Open a terminal, move into the project you want to work on, and start 100xprompt:
cd my-project
100xprompt
The terminal interface opens with your project in context. You can also point it at a directory explicitly:
100xprompt ~/code/my-project
Launch inside a git repository for your first run. Every change is easy to review with git diff and undo with git checkout if you want a do-over.
2

Sign in to 100xprompt

Sign in to 100xprompt before your first task:
100xprompt auth login
Select 100xprompt and paste the API key from your 100xprompt.com account. Once you see a success message, your credential is saved and you’re ready to work.100xprompt gives you two models - pick whichever fits the task:
ModelBest for
FlashFast, lightweight, everyday steps
ProDeep reasoning, large refactors, and hard problems
Run 100xprompt auth list any time to see which credentials are active. You can connect more any time by running 100xprompt auth login again.
Inside the terminal interface, switch between Flash and Pro at any point with the /models command, and dial in reasoning effort with the variant option.
3

Send your first task

Type a task in plain language and send it. Be specific about the outcome you want:
Add a --version flag to the CLI that prints the package version and exits.
100xprompt reads the relevant parts of your codebase, shares a short plan, and starts working. You watch it move through the phases in real time:
  • Plan - it explains what it intends to change before touching anything.
  • Edit - it opens files and applies focused edits.
  • Verify - it runs the checks that prove the change works: building, running tests, or executing the command.
The clearer the goal, the better the result. “Add tests for the parser and make them pass” beats “improve the parser.” 100xprompt does its best work when it knows what “done” looks like.
4

Approve or deny actions

Whenever 100xprompt wants to do something consequential - edit a file, run a command, or reach outside the project - it pauses and asks. You see a prompt with three choices:
ChoiceWhat it does
Allow oncePermit this single action and continue
Allow alwaysPermit this action and similar ones for the rest of the session
RejectDecline the action; 100xprompt adapts and continues
You stay in control the whole way through. Approving something like running the test suite is safe and expected. If a request looks off, reject it - 100xprompt explains or takes a different route.
Rejecting an action isn’t the end of the task. 100xprompt treats your decision as feedback and re-plans around it. Use it freely to steer the work.
5

Review the change

When the task finishes, 100xprompt summarizes what it changed and why. Confirm the result the same way you’d review any teammate’s work:
git diff
If you want adjustments, say so in the same session - “rename the flag to --ver and update the tests.” 100xprompt continues from where it left off, keeping full context of what it already did.
For a structured second pass over your own changes, run the /review command in the terminal interface. 100xprompt reviews the uncommitted diff before you commit.
6

Try a one-shot headless run

The same agent runs without the interactive interface - useful for scripts, pipelines, and quick one-liners. Pass your task straight to the run command:
100xprompt run "Fix the failing test in the checkout module and explain the root cause"
A few flags make it script-friendly:
FlagPurpose
-m, --model <provider/model>Choose the model for this run
-c, --continueContinue the most recent session
-s, --session <id>Continue a specific session
--agent <name>Run with a specific agent
-f, --file <path>Attach one or more files to the task
--format jsonEmit structured JSON events instead of formatted output
Pipe input in for even tighter automation:
git diff | 100xprompt run "Write a concise commit message for these changes"
Use --format json when another program consumes the results. Each step, tool action, and message is emitted as a machine-readable event stream.

​
What you just did

In one session you launched 100xprompt, connected a model, described a task, guided it through approvals, reviewed the result, and ran the same agent from a script. Everything from here is a variation on that loop - bigger tasks, more tools, and more of the work handled for you.
If your change built and its checks passed, you’re ready to move on. If something didn’t land the way you wanted, continue the conversation. Refining in place is the intended workflow, not a workaround.

​
Next steps

How It Works

The mental model behind plan, edit, and verify - and how 100xprompt keeps context across a session.

Capabilities Overview

The full range of what 100xprompt can do, from multi-file edits to running your tools.

Terminal Interface

Get fluent with the terminal experience, its slash commands, and everyday shortcuts.