Hands on the machine
Skills: slash commands for the jobs you repeat
Type / in a Claude Code session to pick up work, hand it over, get a second opinion or ship a pull request, the same careful way every time.
7 min read
Turn it on in Agent features Some jobs are the same every time: pick up where yesterday's work stopped, hand a piece of work to a teammate, get a second opinion before shipping, see a pull request through to merge. An agent asked to do one of these from scratch does it a little differently each time, and skips steps. Skills are the codecast versions of those jobs, written down once: slash commands your agent runs the same careful way every time.
What makes them worth having is that they reach past one session. A skill can read your task board, your team's earlier sessions, other sessions working right now, pull requests, calls and team chat, which a single agent on its own can't see.
Turn it on
Skills work with Claude Code.
- Open Agent features from your account menu and pick the computer your agents run on.
- Switch on Skills, under Tracking & automation.
- Start a new session. The commands are there.
A skill costs nothing until it runs. Your agent sees a one-line description of each, and reads the steps only when one is used.
Use one
Type / in the message box of any Claude Code session, in the web app or the Mac app, and a menu lists the commands available there. Keep typing to filter, and pick one with the arrow keys and Enter. Add anything the skill should know after the name: a task, a file and line, a question.
You don't have to remember the names. Ask in plain words and the agent picks the skill that fits: "hand this over to tomorrow's session", "get another model to look at this before I merge", "what did the team do yesterday?"
The skills
Start, stop and hand over:
| Command | What it does |
|---|---|
/cast-pickup | Reads the task, the session's pinned state, what the team did recently and the state of the code, then names the work and the next three steps |
/cast-handoff | Writes down the decisions, what's verified, open questions and next steps as a shared doc, so the next session or a teammate can continue without reading the thread |
/cast-pass | Hands this session to a teammate: it lands in their inbox with where things stand and what's next |
/cast-ask-team | Posts a question to team chat with enough context to answer it cold, pauses the session, and picks up again when someone replies |
/cast-worktree | Moves the work into its own isolated copy of the repository, so it can't collide with other sessions |
Plan and reconsider:
| Command | What it does |
|---|---|
/cast-plan | Explores the code, looks for earlier attempts in past sessions, asks you the open questions, then writes a plan with tasks for the team to review |
/cast-research | Turns the goal into questions about how the code works today, then has a fresh session that never sees the goal answer them with file and line references |
/cast-rethink | Steps back and rebuilds the history of a piece of work from earlier sessions and decisions before touching code |
/cast-bakeoff | Tries several approaches in parallel, one branch of the conversation each, then compares them side by side with a verdict |
/cast-conflicts | Finds other live sessions changing the same files, shows what they changed, and warns them |
Prove and ship:
| Command | What it does |
|---|---|
/cast-verify | Runs the checks, tries the change in your browser or on the command line, and attaches screenshots and output to the task |
/cast-ship | Commits in sensible pieces, opens the pull request, and stays with it so reviews and failing checks wake the session until it merges |
/cast-review | Reviews another session's work from its conversation and changes, and sends it the findings with file and line |
/cast-second-opinion | Has a different model review the change in a fresh context, then checks each finding before acting on it |
/cast-why | Explains why a line of code is the way it is, from the session that wrote it and the message where it was decided |
Run the day:
| Command | What it does |
|---|---|
/cast-morning | What waits on you: sessions that need input, pull requests, ready tasks, what ran overnight, unread chat and mail |
/cast-eod | Closes the day: makes sure each live session says where it stands, writes handoffs, sets up overnight follow-ups, tidies the inbox |
/cast-standup | A digest for a time window from the team's sessions, commits, tasks, pull requests, calls and chat |
/cast-triage | Tidies a crowded inbox: clears finished and stalled sessions and surfaces the few that need you, with a one-line ask each |
/cast-loop | Works through a queue of ready tasks unattended, one fresh session per task, each verified and opened as a pull request for you to merge |
Learn and keep records true:
| Command | What it does |
|---|---|
/cast-learn | Turns what this session learned (your corrections, decisions, gotchas) into guidance the next session will read |
/cast-lessons | Collects the corrections people made across the team's sessions and proposes the guidance that would have prevented each |
/cast-from-call | Turns a call's action items into tasks, each linked to the moment in the transcript where it was agreed |
/cast-org | Talks through who works on what, for agents and people, and posts each agreed change for you to approve |
Build things in codecast:
| Command | What it does |
|---|---|
/cast-mod | Builds a mod (a pane, a command or a new kind of block in the app) with you watching each change live |
/cast-dashboard | Builds a live dashboard as a published page over your team's work and product data; every chart shows its query and refreshes itself |
/cast-motion | Makes an animated explainer, published as a page that plays, scrubs and takes comments pinned to moments |
What you see
The skill shows as a pill on your message, so you can tell at a glance which conversations ran one. The agent's steps appear in the conversation like any others, and what a skill produces lands where it belongs: a handoff as a doc, a plan on the Plans page, evidence on the task, a pull request on its page with the session shown as its shepherd, a dashboard as a published page.
What they will and won't do
- They follow the same rules as the agent. A skill adds no new powers. It is the same agent with the same permissions, following a fixed sequence of steps.
- Leaving a mark still waits for you.
/cast-shipopens a pull request but doesn't merge it./cast-loopnever merges either./cast-orgposts proposals for you to accept rather than changing the org itself. - Your own skills are safe. Turning Skills off removes the codecast skills and nothing else; any skills you wrote yourself stay.
- They stay current. When codecast updates, improved skills reach your machine without you doing anything.
When something is off
| What you notice | What to do |
|---|---|
Typing / shows no cast- commands | Check Skills is on for the computer the session runs on, then start a new session |
| The session isn't Claude Code | Skills are Claude Code commands. Ask a Claude Code session, or describe the job in plain words |
| A skill stops to ask you something | Some skills (/cast-plan, /cast-org) interview you on purpose. Answer in the conversation and it continues |
Orchestrating a whole plan across several agents is its own feature; see orchestration.
More guides
Agent features: what your agents know how to do
Switch features on for each computer, and every new session there learns to remember, delegate, track work, show results and use your machine.
Memory: agents that look up past work
Your agents search every session you can see, across your machines, agents and team, and answer with the session they found it in.
Search your history across every machine
Every computer you connect sends its sessions to one history, searchable from the web, the Mac app and your iPhone.
See which agent session wrote a line
Set Blame to Sessions on any file to see the session behind each line, and open the conversation where it was decided.
Messaging between sessions
Your sessions hand each other results and answers directly, so you stop relaying text between them.
Stable context: sessions that know what's been happening
New sessions start with a short list of what you and your team worked on recently, so they pick up threads instead of starting cold.
See your whole team's agent sessions in one place
Every session your team runs, on every machine and agent, in one live feed and inbox, shared per folder.
Use Codecast with T3 Code
Threads you start in T3 Code appear in Codecast with no setup, beside every session you run anywhere else, ready to search, steer and share. What you get on top, and what stays in T3 Code.
Share a session with your team
Choose what the team sees of a session, share it by link or a few messages at a time, and how that compares to other tools.
Pinned thread state
The agent keeps one short note on each session saying where it stands, above the composer and on its inbox card.
Decisions: asking without interrupting
Agents put the calls only you can make into one queue you clear when you choose to, and each answer goes back to the session that asked.
Team chat with your agents in the room
Channels, threads and DMs where you can hand a session or a role something by mentioning it, while agents stay quiet unless they're needed.
Huddles, transcripts and walkie
Every huddle is transcribed under each speaker's name and leaves a summary, so your agents can quote what was said, and a session can join the call.
Workers, forks and switching agents
Your agent can hand work to workers that report back to it, and you can fork a conversation to try two directions from the same point.
Tasks and plans
Agents file the work they take on, post progress and close it with what they verified, and you follow it on the Tasks and Plans pages.
Triggers
Agents schedule their own follow-ups, once, on a schedule or on a GitHub or Linear event, and you can set one yourself from the Triggers page.
Workflows
A fixed sequence of agent steps, checks and approval gates that runs the same way every time and waits for you where you want a say.
Orchestration
Hand an agent a whole plan and it runs a team: implementers working in parallel, a reviewer on every task and critics on the result.
Pull requests and issues
Every pull request gets a page with its checks and threads, the session that opened it fixes what reviewers and CI flag, and Linear or GitHub issues become tasks.
The org: roles that look after your work
Give lasting work to a role with an area, a charter and a standing session, and approve the changes your agents propose to the org.
Let agents use your Chrome
Agents check pages in the Chrome you already use, logins included, from their own background tabs. Screenshots and errors come back to the conversation.
Vault: keys, logins and sign-ins for your agents
Fill a credential once and every agent on every machine can use it, without the value ever entering a conversation.
Computer use: agents in your Mac apps
Agents work in Preview, Slack, System Settings or your own desktop build, in the background, with an orange pointer that shows where they act.
Typecheck: one shared check for every agent
With Typecheck on, agents on a computer share one typecheck per project, so checks answer in seconds and a busy machine stays usable.
Run sessions on other machines and in the cloud
Start a session on another computer or a cloud machine in your AWS account, move it there and back, and watch it from anywhere.
Codex Cloud tasks in codecast
Bring your Codex Cloud tasks into your inbox, start new ones with several attempts, and turn the result into a pull request or local changes.
Usage limits are a pause
When a Claude plan runs out, sessions wait for the reset or continue on another account you've saved, instead of stopping for good.
The visual canvas
Agents answer with charts, comparisons and diagrams drawn right in the conversation when a picture says it better than text.
Published pages
Agents turn reports and mockups into pages with their own link that you can share, gate, and get comments on.
Why codecast feels instant, even offline
Everything you see comes from a copy on your device that the server keeps current, so screens open at once, your edits show immediately, and nothing is lost offline.