Summary of Professional Terminology You Can Use in Grill-Me

@mattpocockuk’s Grill-Me series of Skills features a remarkably clean and elegant design. Before opening the Skill documentation, it’s hard to believe that the core of the powerful Grill-Me consists of only three sentences.

One key reason is that he uses many professional terms that are both AI-friendly and rich in meaning.

This article summarizes the high-value professional terms from Matt’s series of Skills, which you can immediately apply to your own Skills.

Tracer Bullet

From the book The Pragmatic Programmer. Literally, a “tracer bullet.” During nighttime shooting, a machine gunner can’t see the bullet trajectory. Tracer bullets emit light after firing, helping the gunner correct aim偏差.

In software engineering, it refers to a vertical-slice development strategy. For example, you need to build a complete feature:

User uploads file → Backend parses → Store in database → Frontend displays

If you ask AI to do it directly, it will:

• Implement the model
• Implement backend parsing logic
• Implement the API
• Implement the frontend

This is a horizontal-slice strategy—completing one layer, then moving to the next.

Disadvantages of horizontal slicing:

• Feedback arrives too late: the frontend is the last layer
• Easy to get abstractions wrong: often implement methods “needed by later layers” that are never actually used
• Difficult to perform integration and e2e testing

When you mention the Tracer Bullet development mode, AI will first implement a very thin end-to-end path:

• Upload the simplest file
• Backend reads one line of content
• Store one minimal record
• Frontend displays that single record

Though rudimentary, it vertically slices all layers. Subsequent implementations extend from this foundation, much like a tracer bullet correcting aim.

In Matt’s Skills, the /to-tickets Skill uses this term to create a vertically-sliced execution plan, while also providing clues for integration and e2e testing in the subsequent /tdd Skill.

Seam

From the book Working Effectively with Legacy Code. Literally, a “seam.” For example, where two pieces of fabric join in clothing is a seam.

It is the point where two pieces meet, can be separated, replaced, and re-stitched.

Understanding “fabric” as “modules in an application,” a seam is the connection point between modules that can be replaced, tested, and isolated.

Concrete code example: You tell the agent: “Write tests for the following module.”

The agent may export and test the discount method independently:

(Example omitted for brevity)

If you tell the agent: “First find the seam of this module, then test the behavior at the seam,”

The agent will recognize finalPrice as the actual seam—the interface that external callers truly interact with. The tests then become:

(Example omitted for brevity)

In summary, “First find the module’s seam” pulls AI away from testing internal details and toward testing behavior at the module’s public boundary.

In Matt’s Skills, /to-spec identifies seams, and /tdd uses seams as entry points for generating test cases.

Design Tree

From the book The Design of Design. This is a design concept that views design as a tree of interdependent decisions, where each branch represents a choice, constraint, or unresolved issue.

It primarily comes into play during the “aligning requirements between human and AI” phase, e.g., in /grilling:

“Walk through every branch of the Design Tree, resolving dependencies between decisions one by one. For each issue, provide your recommended answer.”

Another common way to “align requirements” is Superpowers’ brainstorming. The difference:

• Design Tree assumes you already have a solution in mind but lack details. It’s like breadth-first traversal.
• Brainstorming assumes you only have a vague idea, and AI gives you direction based on that idea. It’s like asking for directions: a passerby points you in a direction, you walk a bit, ask again, until you reach your destination.

From an implementation perspective, using the Design Tree yields more detailed requirements, at the cost of being grilled on more specifics.

Throwaway Prototype

From The Pragmatic Programmer. Refers to a prototype built for verification and then discarded. The difference from Tracer Bullet:

• Tracer Bullet: an end-to-end prototype that later features build upon.
• Throwaway Prototype: a prototype that is abandoned once a conclusion is reached.

If you tell an agent: “Help me implement a demo,” it tends to produce a minimal viable product.

But if you say: “Help me implement a Throwaway Prototype to verify XXX,” it will design the demo around the specific problem you want to verify, ignoring unrelated areas like code quality, infrastructure, and testing.

In Matt’s Skills, /prototype is used during /grilling to verify conclusions when encountering uncertain issues.

Afterword

There are some other terms (e.g., TDD) that are too well-known to list here.

If you find this article useful, please give me feedback. I will collect more professional terms from other well-known Skills in the future.