Real-World Engineering Skills: From Unslop to Deep Architecture Refactoring

In Lesson 1 and Lesson 2, we introduced the concept of skills: reusable, version-controlled markdown packages that shape how agents think and act. But what does a battle-tested production skill look like in practice?

This lesson dissects the most influential open-source agent skills in modern software engineering—from style-purging filters like Cursor's unslop to Matt Pocock's masterclass engineering suite: grill-with-docs, to-spec, to-tickets, improve-codebase-architecture, and codebase-design.

The Anatomy of Real-World Skills

Real-world skills fall along a spectrum ranging from Constraint Filters (deterministic style/tone enforcement) to Cognitive Interviewers (extracting implicit design decisions) to Architectural Engines (analyzing module depth and connascence).

• Type 1 — Deterministic Filters (e.g. unslop): Applies zero-shot structural rules to strip out LLM hallucinations, chatbot sycophancy, superficial phrasing, and telltale prose patterns.
• Type 2 — Interactive Interviewers (e.g. grill-with-docs): Relentlessly probes user assumptions along a dependency decision tree before writing a single line of production code.
• Type 3 — State Synthesizers (e.g. to-spec, to-tickets): Compresses messy multi-turn conversations into durable decision records and single-context tracer-bullet tickets.
• Type 4 — Architectural Examiners (e.g. codebase-design, improve-codebase-architecture): Applies foundational computer science principles (Parnas information hiding, John Ousterhout deep modules, connascence coupling) to inspect code.

Case Study: unslop (Cursor Plugin Stack)

Created for the Cursor editor plugin ecosystem, unslop is designed to eradicate "AI tells" from documentation, code comments, and technical summaries.

Notice how unslop rejects vague advice like "write naturally". Instead, it provides a numbered catalog of specific syntactic violations:

• Rule 3 — Superficial -ing phrases: Ban "highlighting...", "ensuring...", "fostering...", "showcasing...". Delete or expand with concrete evidence.
• Rule 7 — AI Vocabulary: Purge crucial, delve, enduring, enhance, interplay, intricate, landscape (abstract), pivotal, tapestry, testament, vibrant. Replace with simple nouns and verbs.
• Rule 8 — Fancy ways to say "is": Replace "serves as", "stands as", "boasts" with direct "is" or "has".
• Rule 22 — Sycophantic Chatbot Tone: Strip out "Great question! You're absolutely right!", "I hope this helps!". Respond directly with the data.

The Specification Pipeline: grill-with-docs → to-spec → to-tickets

Matt Pocock’s engineering suite illustrates how multiple skills link together to form an end-to-end software development lifecycle for autonomous agents.

A. grill-with-docs: The Active Interviewer

Most developers make the mistake of asking an LLM to immediately generate code. grill-with-docs forbids immediate implementation.

• It traverses a decision tree: only asking questions whose prerequisites have already been answered.
• It produces tangible collateral as it goes: drafting ADR-001.md (Architecture Decision Records) and appending definitions to GLOSSARY.md.

B. to-spec: Capturing the Cleared Path

When a task spans multiple agent sessions, conversation history explodes. to-spec halts discovery and creates a frozen specification:

• It does not ask new questions; it synthesizes existing consensus.
• It produces a self-contained specification that a brand-new agent session with zero memory can execute with full fidelity.

C. to-tickets: Vertical Slices over Horizontal Layers

Horizontal slicing (e.g. "Ticket 1: write all schemas", "Ticket 2: write all endpoints", "Ticket 3: write all frontend") is an AI anti-pattern: nothing works until the very end, and error states accumulate silently.

• Tracer Bullets: to-tickets enforces vertical slices. Each ticket delivers a complete end-to-end path (Schema + Route + UI + Test) for a single capability.
• Context-Sized: Every ticket is explicitly scoped to be completable inside a single fresh context window.

Architectural Skills: codebase-design & improve-codebase-architecture

The most advanced skills don't just format text; they encode rigorous software engineering theory into the agent's analytical lens.

codebase-design: Deep Modules & Information Hiding

Based on John Ousterhout’s A Philosophy of Software Design and David Parnas’s classic paper on modularization, this skill arms the agent with an unambiguous design rubric:

• Deep Module: High leverage. A small, clean interface hiding immense internal complexity, state management, or concurrency.
• The Seam Rule: "One adapter is a hypothetical seam. Two adapters make a real seam." Forbids agents from introducing speculative abstractions before a second live consumer exists.
• The Deletion Test: Can an entire capability be deleted in a single commit by deleting its module folder without modifying callers across five other domains?

improve-codebase-architecture: Hunting Connascence

This skill directs the agent to scan codebases for leaking concerns using Connascence (the degree to which a change in one component forces a change in another):

References & Primary Skill Repositories

• Cursor Plugins: unslop/SKILL.md — The canonical pattern-removal filter for technical prose.
• Matt Pocock: grill-with-docs/SKILL.md — Socratic design interviews that generate ADRs and domain glossaries.
• Matt Pocock: to-spec/SKILL.md — Synthesizing multi-turn conversations into frozen specification issues.
• Matt Pocock: to-tickets/SKILL.md — Decomposing specs into context-sized vertical tracer-bullet tasks.
• Matt Pocock: improve-codebase-architecture/SKILL.md — Parnas secrets and Connascence coupling analysis.
• Matt Pocock: codebase-design/SKILL.md — Deep module design vocabulary and architectural seams.