playbooks

home / skills / plaited / agent-eval-harness / scaffold-rules@plaited_development-skills

scaffold-rules@plaited_development-skills skill

/.plaited/skills/scaffold-rules@plaited_development-skills

This skill scaffolds development rules for AI coding agents, enabling quick setup of consistent conventions and environments.

This is most likely a fork of the scaffold-rules skill from plaited
npx playbooks add skill plaited/agent-eval-harness --skill scaffold-rules@plaited_development-skills

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

Files (1)
SKILL.md
2.1 KB
---
name: scaffold-rules
description: Scaffold development rules for AI coding agents. Auto-invoked when user asks about setting up rules, coding conventions, or configuring their AI agent environment.
license: ISC
compatibility: Requires bun
allowed-tools: Bash
---

# Scaffold Rules

Scaffold shared development rules for AI coding agent environments.

## When to Use

Use when the user wants to:
- Set up development rules or coding conventions
- Configure their AI coding agent environment
- Add project guidelines for Claude, Cursor, or other agents

## Workflow

### Step 1: Preview Changes (Optional)

```bash
bunx @plaited/development-skills scaffold-rules --dry-run
```

Review the `actions` array to see what will be created.

### Step 2: Run Scaffold

```bash
bunx @plaited/development-skills scaffold-rules
```

This will:
1. Copy rules to `.plaited/rules/` (canonical location)
2. Create symlinks in `.claude/rules` and `.cursor/rules` (if those directories exist)
3. Fallback: append links to `AGENTS.md` if no agent directories found

### Step 3: Report to User

Tell the user what was created based on the `actions` output.

## CLI Options

| Flag | Description |
|------|-------------|
| `--list`, `-l` | List available rules without scaffolding |
| `--dry-run`, `-n` | Preview actions without making changes |

## How It Works

```
.plaited/rules/          ← Canonical location (files copied here)
    ├── testing.md
    ├── bun.md
    └── ...

.claude/rules -> ../.plaited/rules   ← Symlink (if .claude/ exists)
.cursor/rules -> ../.plaited/rules   ← Symlink (if .cursor/ exists)
```

| Project has... | Copy | Symlinks | AGENTS.md |
|----------------|------|----------|-----------|
| `.plaited/` only | ✓ | None | No |
| `.claude/` only | ✓ | `.claude/rules` | No |
| `.cursor/` only | ✓ | `.cursor/rules` | No |
| `.plaited/` + `.claude/` | ✓ | `.claude/rules` | No |
| `.plaited/` + `.cursor/` | ✓ | `.cursor/rules` | No |
| `.plaited/` + `.claude/` + `.cursor/` | ✓ | Both | No |
| None of the above | ✓ | None | ✓ Append links |

## Related Skills

- **validate-skill** - Validate skill directories against AgentSkills spec

Overview

This skill scaffolds shared development rules and coding conventions for AI coding agent environments. It automates copying canonical rule files into a central location and creating symlinks for agent-specific directories, making consistent guidance available to agents like Claude and Cursor. Use it to standardize agent behavior and developer expectations across projects.

How this skill works

The skill copies a set of rule documents into a canonical .plaited/rules directory and then creates symlinks in agent folders (.claude/rules, .cursor/rules) when those directories exist. If no agent directories are present, it appends rule links to AGENTS.md so rules remain discoverable. A dry-run mode previews the actions array so you can review changes before applying them.

When to use it

  • You need a canonical place to store agent development rules and guidelines.
  • Onboarding new contributors who must follow consistent coding conventions for AI agents.
  • Configuring or synchronizing rule sets for multiple agent runtimes (Claude, Cursor, etc.).
  • Preparing a repository for automated agent evaluation or multi-agent workflows.
  • Wanting a safe preview of filesystem changes before committing them.

Best practices

  • Keep rule documents concise, actionable, and version-controlled in .plaited/rules.
  • Run with --dry-run (-n) first to inspect the planned actions array before making changes.
  • Use symlinks so updates to the canonical rules propagate automatically to agent folders.
  • Include agent-specific notes in the same files or small companion files—avoid duplicate authoritative content.
  • Commit the .plaited/rules content and any AGENTS.md links to the repository for traceability.

Example use cases

  • Create a unified testing and linting guideline set for agents that run code during evaluation.
  • Add project-specific conventions (bun, TypeScript, Unix pipeline patterns) so agents generate consistent outputs.
  • Synchronize rule updates across .claude and .cursor runtime folders via symlinks.
  • Append links to AGENTS.md in a repository that lacks explicit agent directories to make rules visible.
  • Preview the scaffold plan in CI to ensure no unexpected filesystem modifications occur.

FAQ

What does --dry-run show?

It prints an actions array that lists files to be copied, symlinks to be created, and any AGENTS.md updates without modifying the filesystem.

Will existing files be overwritten?

The scaffold reports planned actions; follow the dry-run output to confirm. Typical behavior is to copy canonical files and create symlinks—inspect conflicts before applying.