Start here

Your first hour

The loop most people settle into, and the six keys worth learning on day one.

Nothing here is required reading. It's the shape of a normal session, so the rest of the docs have somewhere to hang.

The loop

Code

csc                                   signed in, scoped, grounded
> /plan add rate limiting to the API   drafted against what the project
>                                      already decided; y saves it
> implement the plan                   edits and tests, asking before
>                                      anything risky
> /undo                                the whole turn, reverted
> what did we decide about retries?    answered from your own history
> /review                              your changes, read against your
>                                      project's conventions
csc --continue                         tomorrow: same local thread, still grounded

Start with a plan, not a prompt

For anything bigger than a one-liner, /plan <goal> is worth the extra step. It drafts an approach, argues with itself about it, and checks it against what your project has already decided. You get something to read and correct before any file changes.

Press y and the plan and its tasks are saved — they survive the session, and tomorrow's session picks them up.

Decide how much it asks

Out of the box it asks before running commands or writing files. Once you trust what it's doing on a given project:

Code

/permissions auto      trusted for this project
/permissions auto global   everywhere
/permissions plan      read-only: it can look, not touch

The current mode always shows under the prompt box. Deciding what runs without asking covers the whole model — it's worth ten minutes before you turn prompts off.

Everything is reversible

/undo restores every file the last turn touched. /redo puts it back. This is a checkpoint of the working tree, not a git operation, so it works whether or not you've committed.

Knowing that, you can let it try things.

Six keys

Key	What it opens
`CtrlM`	Model picker — managed tiers and your own keys
`CtrlK`	What it currently knows: session, project, memory
`CtrlD`	Agents — live runs, the grid, launching new work
`CtrlR`	Search everything you've typed this session
`CtrlP`	The file tree
`CtrlV`	Paste — a screenshot on the clipboard attaches for vision

/s lists every shortcut. /help lists every command. Neither leaves your session.

Ask it about your own project

This is the part that doesn't work in a fresh chat window:

“what did we decide about retries?”

The decision, when it was made, and what it replaced.

“what were we working on last week?”

The sessions, what changed, and where you stopped.

“why is this function shaped like this?”

The reasoning, if it was ever captured — and honest silence if it wasn't.

Come back tomorrow

Terminal

csc --continue     # reopen the last local session
csc                # fresh session, same project memory

Long sessions compact themselves: older turns fold into a summary so you don't hit a wall, and a bookmark is saved so the next session can pick up the thread.

If it doesn't work

It doesn't seem to know anything about the project. Indexing may still be running — /index shows progress. Memory also starts empty on a brand-new project; it fills as you work.

It asks permission for everything. That's the default. /permissions auto once you're comfortable, or answer a prompt with e to trust that kind of command for this project.

A turn is taking too long. Esc pauses it. Type continue to resume from where it got to — completed edits are kept.