Stop Repeating Yourself. Stop Repeating Yourself. No, Seriously — Put It in a Skill.

Source: Dev.to

Introduction

In my last post I talked about how the workflow is the work, how designing the pipeline matters more than any individual prompt. I still believe that. But I’ve now hit the next layer of the onion: what happens when the pipeline itself becomes repetitive?

The Experiments

I’ve been using Claude Code across five projects:

Different languages, different domains, but apparently very similar habits – and I didn’t notice until I asked.

The Prompt that Started It All

Chintan Turakhia posted a tweet:
“Run this prompt frequently. You’re welcome.”

scrape all of my claude sessions on this computer. give me a breakdown
of all the things i do, things that are worth making into skills vs
plugins vs agents vs claude.md

I ran essentially the same prompt (my version had a few typos). The idea was simple: ask Claude Code to introspect on itself, read through every session I’d ever had, and surface patterns I couldn’t see because I was too close to them.

Claude spawned three sub‑agents in parallel:

1. Global config & plugin explorer – examined my global configuration.
2. Repo crawler – walked every repository, reading every CLAUDE.md and AGENTS.md.
3. Project‑specific analyst – dug into individual project architectures and specs.

In about a minute they collectively mapped my entire Claude Code ecosystem.

Findings: Validation + Embarrassment

Validation

• I had a feature‑planning pipeline: openspec proposal → beads decomposition → worktree → implement → merge → clean‑up.
• I used a sophisticated agent‑team pattern with typed agents and context‑aware respawning.
• I had a review pipeline with dedicated expert agents for security, architecture, and code quality.

These were real workflows that worked.

Embarrassment

• I was re‑stating the same ground rules in virtually every session:
  • “Never use Python.”
  • “Always use Bun.”
  • “Use Claude Code’s native tools instead of sed/awk.”
  • “Agents must commit frequently but not step on each other.”
  • “All features start with an openspec.”

These rules lived scattered across AGENTS.md files in every project, were repeated inline whenever Claude forgot, and sometimes contradicted each other between repos. I was spending real tokens and time repeating myself to an LLM—ironic for a “workflow engineer” with a messy workshop.

Immediate Action

I looked at the analysis and acted immediately, without breaking the session:

Plan

• Add recommended things to a global claude.md and remove them from projects.
• Create a new project in ~/repos/ to host all recommended plugins.
• Implement openspec-and-beads skill.
• Implement agent-team skill.
• Write a comprehensive README with the implemented skills and a todo list.

Note: Do not connect any of the new skills yet; I’ll make a GitHub repo and publish them there.

The session pivoted from analysis → planning → execution, exactly the pattern Claude had just identified. Recursive in the best possible way.

Execution Details

Claude entered plan mode, loaded two meta‑skills (executing-plans and writing-skills), and broke the work into three batches.

Batch 1 – Global Conventions

• Created a global ~/.claude/CLAUDE.md containing all universal conventions.
• Surgically removed duplicated rules from each project’s config.
• Each repo now contains only project‑specific information.
• One file, in one place, read by every future Claude session → no more “never use Python” on repeat.

Batch 2 – Openspec Integration

• Instead of embedding massive documentation inline, each repo now contains a one‑liner pointing to the new skill.

Batch 3 – Skills Repository

Created ~/repos/claude-skills/ with three complete skills:

~/repos/claude-skills/
├── README.md
├── plugin.json
├── marketplace.json
├── skills/
│   ├── openspec-and-beads/
│   │   └── SKILL.md
│   ├── agent-team/
│   │   └── SKILL.md
│   └── use-bun/
│       └── SKILL.md

openspec-and-beads skill

Formalized my most‑used workflow:

1. Gather project context.
2. Scaffold a change proposal with motivation and delta specs.
3. Decompose into prioritized beads linked to an epic.
4. Track during implementation.
5. Archive when done.

Before this existed as a skill, I re‑explained the concept for every new feature. Now it’s a single invocation.

agent-team skill

Captured the coordination pattern for running multiple agents in parallel.
Key insight: the “cover agent” pattern – when an agent reaches ~50 % of its context window, let it finish its current task, create a new bead for the remaining work, and respawn a fresh agent to pick it up.

Additional rules codified:

• One agent per file to avoid merge conflicts.
• Commit at every logical checkpoint.
• Shut down in reverse dependency order.

use-bun skill

A quick reference card: a lookup table for Bun equivalents of common Node/npm patterns (e.g., bunx tsc --noEmit instead of npx tsc, Bun.file() instead of fs.readFile). Tiny, but it eliminated a whole class of “how do I do X with Bun again?” questions.

Reflections on Testing

The writing-skills meta‑skill recommended full TDD for new skills: write tests, watch them fail, then implement. Claude’s response was pragmatic:

“This content was already empirically validated across hundreds of messages and 240 sessions. The ‘tests’ have already been run, organically, over weeks of real usage.”

It proceeded directly to writing the specification.

That felt right. TDD for a skill isn’t the same as TDD for code. The validation had already happened in practice. The goal of this exercise was to capture what was already working, not to discover new behavior. Sometimes the best test suite is “I did this 50 times and it works.”

Final Repository Layout

~/repos/claude-skills/
├── README.md
├── plugin.json
├── marketplace.json
├── skills/
│   ├── openspec-and-beads/
│   │   └── SKILL.md
│   ├── agent-team/
│   │   └── SKILL.md
│   └── use-bun/
│       └── SKILL.md

Takeaways

• Self‑analysis can surface hidden duplication in even the most disciplined pipelines.
• Consolidating universal conventions into a single global file eliminates token waste and keeps the workshop tidy.
• Turning recurring patterns into reusable skills turns “re‑explaining” into a one‑click operation.
• Meta‑skills (plan‑execution, writing) can bootstrap the very process they describe—recursive, but powerful.

If you’re a workflow engineer (or anyone who spends a lot of time prompting LLMs), consider giving your own pipeline a mirror‑run: let the model introspect, then act on the insights before the next session. The payoff is a cleaner, faster, and more self‑aware development environment.

“Your LLM conversations are data. 240 sessions contained patterns I couldn’t see because I was living inside them. Having Claude analyze its own session history was like running a profiler on your own workflow; the hot paths become obvious. If you haven’t done this yet, do it.” – Chintan

Global config eliminates an entire class of wasted tokens. Every “never use Python” I typed was burning context and attention. A single CLAUDE.md in ~/.claude/ fixed that permanently. If you’re using Claude Code across multiple projects, this is probably the highest‑ROI thing you can do right now.

Skills are just formalized habits. I didn’t settle on the openspec‑and‑beads workflow during this session; I’d been doing it for weeks. The skill just wrote down what was already true. If you find yourself explaining the same process to Claude more than twice, it belongs in a skill—not a prompt, not a CLAUDE.md entry, a skill. The distinction matters because skills carry context, structure, and sequencing that a flat config file can’t.

The “cover agent” pattern deserves to be a first‑class feature. Monitoring an agent’s context utilization and strategically respawning it before it degrades, assigning the remaining work as a new task, is something I’m doing manually—in 2026. While Anthropic ships yet another benchmark blog post, the fact that I have to write a skill to manage context windows because the tool won’t do it for me is… a choice. Anthropic, if you’re reading this: please steal this idea. I’m begging you.

Open TODOs

• A beads MCP plugin so agents can query and update task status natively instead of shelling out to bd commands.
• A review pipeline skill for spawning expert agents and turning their findings into follow‑up beads.
• A branch‑cleanup skill because the merge‑delete‑remove dance is identical every single time and I’m tired of typing it.

The session that produced all of this took about 22 minutes: three subagents, a lot of pattern recognition, and a pivot from “hmm, I wonder what I actually do” to shipping a plugin repo on GitHub. Not bad for a Saturday morning.