Everyday tasks

Syntic Code ships with commands for the jobs developers do every day. Each one turns into a carefully worded request to the agent, so you get a consistent result without retyping instructions. This page also collects prompt ideas and habits that make sessions go smoothly.

Get to know a codebase

Prompt ideas:

Trace what happens from the moment a user clicks "Pay" to the row landing in the orders table.
Which modules would I touch to add a new export format? List them with one line each.
Where are feature flags read, and which ones are dead?

Plan before you build

• /plan switches to plan mode: the agent reads and proposes but changes nothing. /plan <task> switches and sends the task in one go. When the plan looks right, approve it and the agent starts working.
• /ultraplan <task> asks a background subagent for a long-form plan (goal, what exists, approach, steps, risks, tests, open questions). It writes the plan to your plans folder (~/.syntic/plans) and reports the file path when done.

Reviews

/code-review levels:

With no level, the one you used last in the session is reused (medium the first time). --fix applies the fixes afterwards; --comment posts the findings as pull request comments (needs the gh CLI); --max-findings changes the cap.

Commits and pull requests

Pushing to a remote always asks for your OK in auto mode. Commits get an attribution line by default; change or remove it with the attribution setting (Settings keys).

Big changes in parallel

• /batch <task> splits a large change into parts and runs them with parallel agents; every agent gets a separate git worktree. See Parallel work with worktrees.
• /init-verifiers sets up automated checks the agent can run to verify its own work in this project.

Quick questions on the side

/btw <question> asks something without derailing the current task. The answer is shown, but it is not added to the main conversation. /btw on its own lists recent side questions.

Show it, do not describe it

Prompts that work well with images: “Build this form to match the mockup”, “What is wrong with the layout in this screenshot?”, “Turn this whiteboard photo of the schema into a migration”.

Think harder on hard problems

For tricky bugs, architecture questions and plans, give the model more room to reason:

• /effort cycles the reasoning effort (low, medium, high). Higher effort is slower and costs more, and pays off on problems with many moving parts. See Models & reasoning.
• Alt+T turns reasoning on or off; /thinking expands or collapses the reasoning blocks in the transcript.
• Ctrl+O opens the full transcript, including tool calls and reasoning, when you want to see how it got somewhere.

Use it as a command-line tool

syntic -p reads standard input and prints a result, so it fits into pipes and scripts:

# explain a failure
cat build.log | syntic -p "what is the root cause? one paragraph"
 
# write a commit message
git diff --staged | syntic -p "write a conventional commit message for this diff"
 
# machine-readable output
syntic -p "list the public functions in src/lib.rs" --output-format json | jq -r .result

Add it to package.json scripts, git hooks or CI jobs. See Scripting and CI.

Pick up later, or try another way

See Sessions and resume and Checkpointing.

Ask about Syntic Code itself

“How do I add an MCP server?”, “What does /goal do?”, “Can you run in CI?” are fair questions in any session. A built-in guide agent answers questions about Syntic Code’s own features. /help lists the commands, /keybindings the keys, and /powerup gives short lessons on features that are easy to miss.

Prompt ideas

Many more, grouped by task, are in the Prompt library.

Habits that pay off

The longer version, with examples, is Best practices.

• Say what done looks like. “Tests pass and the CLI prints the new column” beats “improve the output”.
• Hand it a yardstick. Mention the test or build command, or put it in SYNTIC.md, so the agent can verify before it reports back.
• Plan first for anything big. A minute in plan mode saves a lot of rework.
• Keep sessions focused. One task per conversation; /clear between unrelated jobs.
• Interrupt early. If the agent heads the wrong way, press Esc, say what to change, and send again.
• Write lessons down. When you correct the same thing twice, add it to SYNTIC.md (start a message with # to do it in one step).
• Let rules do the approving. If you keep clicking yes for the same safe command, add an allow rule instead (Permissions).