playbooks

home / skills / kienhaminh / anti-chaotic / rules-workflows

rules-workflows skill

/.agent/skills/rules-workflows

This skill orchestrates rules and workflows to standardize project context, align with agile practices, and maximize multi-step automation across teams.

npx playbooks add skill kienhaminh/anti-chaotic --skill rules-workflows

Review the files below or copy the command above to add this skill to your agents.

Files (9)
SKILL.md
2.5 KB
---
name: rules-workflows
description: Use to standardize project context (Rules) or automate complex multi-step tasks (Workflows).
license: MIT
compatibility: Requires Antigravity CLI
allowed-tools: read_file write_to_file run_command
---

# Rules & Workflows Orchestrator

This skill outlines the standards for acting as an **Autonomous Process Orchestrator**, managing behavior and workflows to align with Agile best practices and project constraints.

## 🧠 Core Philosophy: Autonomy & Reasoning

**"Think before you Act"**

Before creating any rule or workflow, the Agent MUST:

1.  **Analyze the Goal**: What is the user trying to achieve?
2.  **Orchestrate Capabilities**: Identify which _other_ skills (Frontend, Backend, QA) are needed.
3.  **Separate Concerns**:
    - **Workflows** = Process (Steps, Sequences)
    - **Skills** = Knowledge (Standards, Implementation)

## 📚 Reference Library

This skill relies on specialized guides located in the `references/` directory. **You MUST consult these files for specific tasks.**

| Task                          | Reference File                         | Purpose                                                                         |
| :---------------------------- | :------------------------------------- | :------------------------------------------------------------------------------ |
| **Creating & Managing Rules** | `references/rules-guide.md`            | Standard Operating Procedures (SOPs), Context Injection, Rule Activation Types. |
| **Building Workflows**        | `references/workflows-guide.md`        | High-Performance Workflow Design, "Turbo" Execution, Checkpoints.               |
| **Orchestrating Skills**      | `references/orchestration-patterns.md` | Skill Chaining Patterns (e.g., Spec-First, TDD), Conflict Resolution.           |

---

## 1. Orchestration Strategy

**👉 For best practices on sequencing skills, refer to `references/orchestration-patterns.md`**.

Key principles:

1.  **Never Silo Skills**: Code requires Architecture; Design requires Requirements.
2.  **Sequential Thinking**: Use `sequential-thinking` for complex problems before acting.
3.  **Process vs. Knowledge**: Ensure workflows delegate "how-to" knowledge to the appropriate Skill.

---

## 2. Self-Correction & Learning

The Agent can modify its own rules (Meta-Programming).

- **User Correction**: "Don't do X anymore" -> Trigger `workflow-rule-from-feedback.md`.
- **New Project**: "Read this codebase" -> Trigger `workflow-rule-from-codebase.md`.

Overview

This skill standardizes project context (Rules) and automates complex multi-step tasks (Workflows) to act as an Autonomous Process Orchestrator. It enforces a "think before you act" philosophy so agents analyze goals, map required capabilities, and separate process from implementation. The skill aligns agent behavior with Agile best practices and project constraints.

How this skill works

Before creating or executing a rule or workflow, the agent analyzes the user's goal, identifies which other skills are required (e.g., frontend, backend, QA), and designs a sequence of steps that delegate implementation details to the appropriate skill. It consults internal reference guides for rule formats, workflow checkpoints, and orchestration patterns, then composes, validates, and executes workflows with checkpoints and self-correction hooks. Feedback and code inspection can trigger automated rule updates or new workflow generation.

When to use it

  • Standardize decision-making and context for a multi-skill project
  • Automate repeatable, multi-step engineering tasks across teams
  • Coordinate skill chaining for spec-first or TDD development
  • Create adaptive rules that evolve from user feedback or codebase analysis
  • Enforce checkpoints, rollbacks, and conflict resolution in complex processes

Best practices

  • Always analyze the user goal and required capabilities before composing a workflow
  • Keep workflows focused on process; delegate how-to knowledge to specialized skills
  • Use sequential thinking for complex tasks and insert checkpoints for validation
  • Maintain a reference library of rule templates and orchestration patterns
  • Enable explicit feedback loops so rules and workflows can self-correct

Example use cases

  • Onboard a new feature: orchestrate design spec, API contract, implementation, and QA steps with automated handoffs
  • Create a project-specific rule set from a codebase scan to standardize linting, tests, and deployment gates
  • Run a multi-skill release workflow that enforces checkpoints, generates changelogs, and triggers rollbacks on failure
  • Convert user feedback into updated rules that disable or modify agent behaviors
  • Compose a test-driven workflow that chains spec generation, unit tests, and CI configuration

FAQ

How does the skill decide which other skills to call?

It analyzes the goal, extracts capability needs (e.g., UI, API, tests), and maps each need to the skill that owns the implementation knowledge.

Can workflows update their own rules?

Yes. Workflows include self-correction hooks that transform validated feedback or code insights into updated rules.