Skills vs Instructions: What's the Difference?

When you first open Automatic, you'll see two main concepts: Skills and Instructions. Both influence how your AI agents behave, but they work differently and serve different purposes.

Understanding the distinction will help you get the most out of Automatic.

What Are Instructions?

Instructions are persistent guidance that lives in your agent's context at all times. They tell the agent how you want it to behave in general.

Think of Instructions like an onboarding document you'd give a new team member. They cover:

• Your preferred coding style and conventions
• Languages, frameworks, and libraries you use
• Things the agent should always do (or never do)
• Project-specific context the agent needs to do its job

Instructions are applied globally across all your agents by default, though you can scope them to specific tools or projects if needed.

A good set of Instructions might look like this:

You are working on a TypeScript monorepo using pnpm workspaces.
Always prefer explicit types over `any`.
Use Zod for runtime validation.
When writing tests, use Vitest and prefer unit tests over integration tests.
Never commit directly to `main` — always create a feature branch.

Short, direct, and consistently enforced across every agent you use.

What Are Skills?

Skills are modular, task-specific capabilities you load into an agent for a particular kind of work. They're more structured than Instructions and are designed to be shareable and reusable.

A Skill might include:

• A detailed workflow for a specific type of task (e.g. "write a pull request description")
• Domain-specific knowledge the agent doesn't have by default (e.g. internal API conventions)
• Tool usage patterns for a specific MCP server
• A set of rules and heuristics for a particular engineering discipline (e.g. "security review checklist")

Skills are composable. You can install multiple Skills and they stack. The agent draws on whichever Skill is most relevant to the task at hand.

When to Use Each

Situation	Use
Set your coding style globally	Instructions
Define project structure and conventions	Instructions
Tell the agent about your team's workflow	Instructions
Add a specialised capability (e.g. Terraform expertise)	Skills
Give the agent a detailed task-specific workflow	Skills
Share a capability with your team	Skills
Install a community-contributed capability	Skills

A Practical Example

Say you're an engineer working across several TypeScript web projects. Here's how you might set things up:

Instructions:

• Your general style preferences (TypeScript strict mode, functional style, etc.)
• Your preferred test framework
• The fact that you use GitHub and prefer conventional commits

Skills:

• playwright — for browser automation and end-to-end testing
• tailwindcss-development — for styling and UI iteration
• vercel-react-best-practices — for React and Next.js implementation patterns
• documentation — when writing READMEs, runbooks, and ADRs

Your Instructions are always active. Your Skills are there when you need them, and you can add or remove them as your work changes.

The Skill Store

Automatic ships with a growing catalogue of Skills built by the community. Browse the Skill Store to find Skills for your stack, and publish your own if you've built something worth sharing.

The Skill Store is powered by the skills.sh registry, so it's a useful place to discover what's available and install community-built skills quickly.