Using Skills and Slash Commands

What you'll learn

• What skills and slash commands are
• How to use built-in commands like /commit and /review-pr
• How to chain prompts with skills for powerful workflows
• How to create and share custom skills with your team

Before you start

Make sure you have the following ready.

Requirements

• Autohand Code installed. Run autohand --version to verify. See Your First Autohand Session if you need to set up.
• A project with git initialized. Skills like /commit need a git repository to work with.

Project setup

Open a terminal and navigate to a project that has some uncommitted changes, so you can try /commit right away.

cd path/to/your-project
autohand

Step 1: Understand skills

Skills are pre-built workflows that automate common tasks. Instead of typing out a long prompt every time you want to do something routine, you invoke a skill with a short slash command and the agent handles the rest.

Each skill is a small program that knows what tools to use, what steps to follow, and what output to produce. Built-in skills cover the tasks developers repeat most often. Custom skills let you encode your own workflows.

Skills are different from plain prompts in one important way: they are repeatable. Running /commit today and running /commit tomorrow produces consistent, predictable results because the workflow is defined, not improvised.

Step 2: Try built-in commands

Autohand ships with several built-in skills ready to use from the first session.

/commit

Stages your changes, writes a commit message based on the diff, and commits. The message follows conventional commit format by default.

/commit
# Staged 4 files
# feat(auth): add refresh token rotation
# Committed as a3f9b2c

/review-pr

Reviews the current branch against main. The agent reads the diff, checks for bugs, security issues, and code quality concerns, then writes a structured review.

/review-pr
# Comparing feature/user-settings against main (14 files changed)
#
# Code Review
#
# Issues found:
# - src/api/settings.ts:42 - User input not sanitized before database write
# - src/hooks/useSettings.ts:18 - Missing error state handling
#
# Suggestions:
# - Consider extracting the validation logic into a shared schema

/help

Lists all available skills in the current session, including any custom skills loaded from your project.

/help
# Built-in skills:
#   /commit         Stage and commit changes with a generated message
#   /review-pr      Review current branch against main
#   /clear          Clear the current session context
#   /help           Show available skills
#
# Project skills:
#   /deploy-staging Deploy to the staging environment
#   /gen-migration  Generate a Prisma migration for recent schema changes

/clear

Clears the session context. Useful when you have finished one task and want to start fresh on something unrelated, without starting a new terminal session.

/clear
# Session context cleared. Starting fresh.

Step 3: Run a skill

To run a skill, type the slash command at the Autohand prompt and press Enter. No other syntax is needed.

/commit

The agent executes the skill's defined workflow. You can watch each step as it runs. When the skill finishes, it shows you the result and returns to the interactive prompt.

Some skills accept optional arguments. Pass them after the command name.

/review-pr --against develop
/commit --message "fix: correct null check in user loader"

Step 4: Chain prompts with skills

Skills work well on their own, but they are more powerful when combined with natural language prompts in a sequence. You can describe what to do first, then invoke a skill to finish the job.

Fix the failing tests, then commit the result.

Fix the failing tests in src/services/auth.test.ts
# ... agent finds and fixes the failures ...

/commit
# feat(auth): fix token expiry check in session validation

Refactor a module, review the changes, then commit.

Refactor the UserService class to use the repository pattern
# ... agent refactors the code ...

/review-pr
# ... agent reviews its own changes and flags anything to revisit ...

/commit
# refactor(users): extract database logic into UserRepository

The agent carries context from the prompts into the skill invocations. When you run /commit after a refactor, the generated message reflects what was actually changed.

Step 5: Create custom skills

You can create skills specific to your project. Project skills live in a .autohand/skills/ directory at the root of your repository.

Create the skills directory

mkdir -p .autohand/skills/deploy-staging

Write a skill definition

Each skill is a directory containing a SKILL.md file. The frontmatter configures the skill. The body describes the workflow the agent follows.

# .autohand/skills/deploy-staging/SKILL.md
---
name: deploy-staging
description: Build the project and deploy to the staging environment. Use after finishing a feature.
allowed-tools: read_file run_command
---

# Deploy to Staging

## Steps

1. Run `npm run build` and confirm it succeeds with no errors.
2. Run `npm test` and confirm all tests pass.
3. Run `npm run deploy:staging` to push to the staging environment.
4. Report the deployment URL from the deploy script output.

## On failure

If any step fails, stop and report the error clearly.
Do not continue to the next step.

Use your custom skill

Start a new session and Autohand loads the skill automatically. It appears in /help and is ready to invoke.

/deploy-staging
# Running build...
# Build succeeded (12.4s)
# Running tests...
# All 84 tests passed
# Deploying to staging...
# Deployed to https://staging.yourapp.com

Step 6: Share skills with your team

Because skills live inside your repository, sharing them with your team requires nothing more than a normal git commit.

git add .autohand/skills/deploy-staging/SKILL.md
git commit -m "chore: add deploy-staging skill for Autohand"
git push

Once the commit is merged, every team member who runs Autohand on the project gets the skill automatically. No configuration, no installation step.

This makes skills a great place to encode team knowledge. Onboarding tasks, release procedures, common debugging workflows: anything a developer would otherwise need to learn by asking a colleague can be captured as a skill.

What you learned

• Used built-in skills like /commit and /review-pr
• Chained natural language prompts with slash commands
• Created a custom skill and shared it through git

Try next