100xprompt is only as good as the way you point it. The difference between a frustrating session and a great one is rarely the model - it’s how clearly you frame the task, how much project context the agent has, and whether you pick the right tool for the job. This page distills the habits that get fast, accurate, trustworthy results. Read it as a set of defaults. Adopt them, then bend them once you know why they exist.

​
Learn the core loop

Almost every effective session follows the same rhythm: give context, frame the task, choose the right agent and mode, review the result, then decide whether to keep going or start fresh. The rest of this page is that loop, tuned.

​
Write task prompts that land

The single highest-leverage skill is stating what you want precisely. 100xprompt will happily infer intent - but every inference is a guess, and guesses cost you review cycles.
Lead with the result you want, name the files or area if you know them, and call out anything that’s already off the table.
“Add rate limiting to the public API handlers. Use the existing middleware pattern in the request layer. Don’t touch the auth code - that’s being reworked separately. Return 429 with a Retry-After header.”
That prompt tells the agent the goal, the pattern to follow, a hard boundary, and the acceptance criteria. It rarely needs a second pass.
“Make the API better.”
The agent has to invent a definition of “better,” pick a scope, and guess your conventions. You’ll spend more time correcting the result than a clear prompt would have taken to write.
“Done when the new tests pass and lint is clean” gives the agent a target it can check itself - and it will run the commands to confirm, rather than handing you something that only looks finished.
Exact stack traces, failing test output, and command logs are gold. Summarizing them throws away the details the agent needs to localize the bug.
Bundled requests produce sprawling diffs that are hard to review and easy to get partly wrong. Do one coherent thing, review it, then move on - or fan the independent parts out to subagents (see below).
When a task is ambiguous, ask 100xprompt to restate its plan before it starts. A one-line “here’s what I’m about to do” catches a wrong assumption in seconds instead of after a 200-line diff.

​
Give it durable project context

A prompt describes one task. Rules and memory describe your project - the conventions that should shape every task without you retyping them.

​
Capture conventions in AGENTS.md

Drop an AGENTS.md at the root of your project (or in a subfolder for area-specific rules) and 100xprompt reads it as standing instructions. This is where your stack, your commands, and your house style live. 
# Project rules

- Package manager is pnpm. Never suggest npm or yarn.
- Run `pnpm typecheck` and `pnpm test` before considering a change done.
- API errors return a typed Result, never thrown exceptions.
- Prefer small, composable functions. No files over ~300 lines.
- Do not edit anything under `generated/` - it's built from schemas.
Keep rules short, specific, and testable. “Write clean code” is noise. “Run pnpm typecheck before finishing” is a rule the agent can actually act on. Prune anything that’s no longer true - stale rules are worse than no rules.

​
Let memory carry the rest

For preferences that emerge mid-conversation - “we always use the repository pattern here,” “I like terse commit messages” - just say them. 100xprompt remembers durable facts across sessions, so you stop re-explaining your world every morning. Review what it holds periodically and correct anything outdated; you stay in control of what survives.
Rules are for things you’d write down deliberately. Memory is for the things you mention in passing that turn out to matter. Use both - they compound.

​
Choose the right agent and model

Not every task deserves your heaviest agent or your most expensive model. Match the tool to the job - that’s where speed and cost savings hide.
For the model itself, the trade-off is depth versus speed and cost. Match the weight of the model to the difficulty of the task.
SituationReach forWhy
You know the change and it’s containedBuild agentFull read-and-write power, gets it done.
Large, risky, or you’re still scoping itPlan modeInvestigates and drafts a plan without touching files.
”Where is X?” / “How does Y work?”Explore subagentFast, read-only codebase search off your main context.
Open-ended research or parallel workGeneral subagentRuns independent multi-step tasks in the background.
Hard refactor, subtle bug, architectureTop-tier reasoning modelDepth matters more than speed here.
Renaming, boilerplate, quick editsLighter, faster modelSave the heavy model for the hard parts.
Give each custom agent the narrowest tool set it needs. A review agent with edits and shell denied physically can’t change your code - that’s a guardrail, not a polite request. See Agents to build your own.

​
Plan before big changes

Suppose you’re about to ask for a change that spans half a dozen files. For anything large or irreversible, spend a turn in Plan mode first. It reads, searches, and reasons across your whole project but is locked out of writing files, running commands, or delegating work - so it can only produce a plan, never a surprise.
1

Switch to Plan mode

Frame the task and let the agent investigate. It maps the relevant code and proposes an approach.
2

Review the plan, not the diff

Correct wrong assumptions here, while it’s cheap. A bad plan caught now saves a bad diff later.
3

Hand the approved plan to Build

Switch to the Build agent and let it execute the plan you already vetted.
The most common way to waste time is skipping the plan on a big task, getting a 400-line diff built on a wrong assumption, and throwing it all away. Five minutes of planning routinely saves an hour of rework.

​
Automate repeatable work with skills and commands

If you find yourself typing the same instructions - how you review a PR, cut a release, write a migration - stop retyping them. Capture the playbook once as a Skill and 100xprompt pulls it in automatically when a task matches. Wrap a frequent prompt in a Command and trigger it with a slash.

Skills

On-demand expertise loaded just-in-time - your team’s playbooks, matched to the task at hand.

Commands

Turn a repeated prompt into a reusable slash command you fire in one keystroke.
A good rule of thumb: the third time you paste the same instructions, turn them into a Skill or Command. The upfront minute pays for itself immediately.

​
Parallelize with background subagents

When a task splits into independent pieces - research the new API and audit the old usage and map the tests - don’t do them one at a time. Have the primary agent fan them out to subagents that run in parallel, each in its own clean context, and report back a concise result.
Subagents don’t share your conversation’s memory. Tell each one what you’re trying to do, what’s already ruled out, and exactly what to report back. A vague brief gets a vague result.
Kick off a build or a big research task in the background and keep working. You get a handle to check status and collect the result when it’s done - no sitting and watching.
A subagent can work in an isolated git worktree so its changes never touch your working tree until you choose to bring them in - and if it changes nothing, the workspace cleans itself up.
Fan-out shines for independent work. Two agents editing the same module at once just create a merge headache. Keep parallel tracks genuinely separate.
See Background Tasks for the full mechanics.

​
Review diffs and use permissions wisely

100xprompt keeps you in control by design: every change lands as a reviewable diff, and permissions gate anything consequential. Use both deliberately.
The agent is fast and usually right - but “usually” is why you review. Skim every diff before you accept it. Approve what’s correct, reject what isn’t, and roll back anything that went sideways.
Allow the safe, high-frequency actions so you’re not clicking through prompts all day; keep an ask-first gate on destructive or irreversible ones. Tune the balance to the work - tighter on production repos, looser on a scratch branch.
Auto-approving every action removes the exact checkpoint that catches a wrong assumption before it hits your filesystem. Speed you can’t trust isn’t speed.
Be especially careful granting broad shell or delete permissions on repositories with production credentials, generated artifacts, or anything you can’t easily restore. When in doubt, keep it on ask.
See Permissions to configure the guardrails.

​
Keep sessions focused, and start fresh when they drift

A session is a train of thought. Long, meandering ones drift: the agent carries stale detail from three tasks ago, and its focus dilutes.

Stay in one session when…

The work is a continuous thread - the same feature, the same bug, the same refactor - where earlier context still matters.

Start fresh when…

You’re switching to an unrelated task, or the conversation has wandered so far that a clean slate would think more clearly than the accumulated history.
100xprompt keeps a single long task coherent on its own, condensing older back-and-forth so a big job can keep going. That’s for one task. When you genuinely change subjects, a fresh session beats stretching an old one - it starts sharp instead of carrying baggage. See Memory & Long Context.

​
The short version

  1. Be specific. State the outcome, the constraints, and how you’ll know it’s done.
  2. Feed it context once. AGENTS.md for conventions, memory for the rest.
  3. Plan before big changes. Vet the plan while corrections are cheap.
  4. Match the tool to the task. Right agent, right model, subagents for parallel work.
  5. Review every diff. Keep permissions honest and start fresh when you switch tracks.

Workflows

Chain these habits into repeatable, end-to-end automations.

Agents & Subagents

Pick the right agent, delegate to subagents, and build your own.

Project Rules

Give 100xprompt standing instructions with AGENTS.md.