As AI-powered coding agents become part of everyday development workflows, the real shift is not just writing code faster but learning how to guide these agents effectively. At the core of this shift are two foundational concepts: Rules and Skills.
Summarize this blog post with:
What are Rules?
Rules act as guardrails for your coding agent. They define how the agent should behave across all tasks.
Think of Rules as your coding standards baked into AI. For example:
- Always use with sharing in Apex classes
- Follow modular design patterns
- Use selector classes instead of inline queries
These are not task specific. They are always applied (as long as enabled), making them ideal for enforcing consistency across your codebase.
However, Rules come with a trade-off. Since they are static and always loaded into context, they can grow large over time. As more rules are added, they increase context size, which can reduce efficiency and even confuse the agent.
Rules are global guardrails that shape how the agent writes code every time.
Example: Apex Coding Standards Rule
Rule Name: Apex Best Practices
- Always use “with sharing” in Apex classes
- Do not write SOQL queries inside loops
- Use a selector class for all queries
- Follow Unit of Work pattern for DML operations
How it works
Whenever you ask the agent:
“Create an Apex class to fetch Accounts”
The agent will:
- Automatically include with sharing
- Avoid SOQL in loops
- Structure code using selector pattern
What are Skills?
Skills represent a more advanced and scalable approach. They are dynamic, task-specific capabilities that the agent can use when needed.
Instead of telling the agent “Always behave this way,” Skills tell the agent:
“When you see this kind of task, use this approach.”
For example:
- A skill to generate Apex test classes
- A skill to build Salesforce screen flows
- A skill to create LWC components
Skills are triggered based on their name and description, and only then does the agent load the relevant instructions. This means they are efficient, modular, and scalable.
Another key advantage is that Skills can include:
- References (documentation, examples)
- Structured steps
- Reusable logic
This allows them to act more like mini playbooks for specific development tasks.
Skills are task-specific capabilities that the agent uses only when needed.
Example: Skill for Creating Apex Test Classes
name: create-apex-test-class
description: Generate a complete Apex test class with best practices, including test setup, data creation, and assertions.
steps:
- Create test data using @testSetup
- Insert required records
- Call the target method
- Add meaningful assertions
- Ensure at least 75% coverage
How it works
When you write a prompt:
“Write a test class for AccountService”
The agent:
- Matches the request with the skill description
- Loads the skill
- Executes structured steps
Output will include:
- @isTest class
- @testSetup method
- Proper assertions
- Clean structure
Key Differences That Matter
The difference between Rules and Skills is not just technical, it changes how you design your AI workflow.
- Rules are global and static
- Skills are modular and dynamic
- Rules enforce consistency
- Skills enable capability
- Rules scale poorly as they grow
- Skills scale well through decomposition
In practice, Rules can quickly become bloated, while Skills encourage breaking problems into smaller, reusable units.
When Should You Use Each?
Use Rules when:
- You need strict enforcement of standards
- The behavior must always be applied
- Example: naming conventions, security requirements
Use Skills when:
- You are solving specific, repeatable tasks
- You want reusable building blocks
- Example: generating flows, writing test classes
Side-by-Side Comparison
| Aspect | Rules | Skills |
|---|---|---|
| Purpose | Enforce standards | Execute specific tasks |
| Nature | Static | Dynamic |
| Context Loading | Fully loaded every time | Loaded on demand |
| Trigger | Always active (if enabled) | Selected based on description |
| Granularity | Broad (global rules) | Fine-grained (task-level) |
| Scalability | Poor (grows large quickly) | High (modular & reusable) |
| Efficiency | Low (context bloat risk) | High (progressive loading) |
| Determinism | Slightly more predictable | Less predictable (depends on matching) |
| Maintenance | Hard as file grows | Easier (split into small units) |
| Best Use Case | Coding standards, naming, architecture patterns | Specific workflows (Apex, Flow, Test class, etc.) |
Moving from Code Writing to Agent Engineering
What’s becoming clear is that development is moving toward engineering the agent, not just the code.
Instead of writing everything line by line, you
- Define Rules for consistency
- Build Skills for capabilities
- Continuously refine both based on outcomes
Over time, Skills will likely become the dominant pattern, with Rules playing a smaller supporting role.
Also Read
Don’t forget to check out: Designing Agent-to-Agent (A2A) Architecture in Salesforce
Final Thoughts
This is the simplest way to think about it when working with AI agents in real projects.
- Rules define how the agent should behave
- Skills define what the agent can do
Once you separate behavior from capability like this, it becomes much easier to design scalable and maintainable AI-driven development workflows.
