The three AI agent skills every engineer should be using

These are three skills I keep coming back to when working with agents. I’m suggesting them because they’re simple. They work at almost any level, and they’re just as useful for knowledge work as they are for engineering.

Agent skills are reusable instructions that teach a coding agent a specific way of working. These three form a useful loop: clarify the problem, make the proposed solution visible, and verify the real product.

They’re atomic, easy to compose with other things, and don’t force you into a particular workflow. They’re also good entry points into the more advanced frameworks created by the people behind them.

Grill Me

Grill Me, by Matt Pocock, flips the usual planning process around. Instead of asking AI to write a plan, you ask it to strategically question you and pull the plan out of you.

There’s real discovery in that process. Your assumptions get checked, your judgment becomes explicit, and sometimes the outcome of a grilling session is that you don’t need to build the thing at all.

The agent will question you and recommend what to do when the answer is clear.

A simple question might look like this:

What should happen when a customer reaches the end of the onboarding flow?

Recommendation: Give them one clear next action and save everything else for later.

Many times, you can sign off on the recommendation and keep moving. When you disagree, that disagreement surfaces something the agent could not have known—or something you had not made explicit yet.

I use Grill Me constantly across different projects. I’ve even used it to plan a trip to Greece. Anytime you have a vague problem, I highly recommend getting creative and trying it. It doesn’t need to be about software.

Grill Me is only the entry point. Matt’s broader AI Skills for Real Engineers system takes the same ideas further into research, specification, implementation, and review. The open-source skills are also available on GitHub.

Show Me

Show Me, by Dex at HumanLayer, fixes one of the most annoying parts of working with coding agents: walls of prose. When you invoke it, the agent stops explaining and picks the smallest view that makes the point clear. A call tree, a file tree, pseudocode, a Mermaid diagram, or a shape-diff of the change. No preamble.

It works because it matches how people actually process information. Reading dense text is exhausting. Seeing structure, flow, and differences is nearly free. That pays off in three places: understanding a large PR without reading everything, designing the shape of code before the agent writes it, and reviewing changes at the right level of abstraction instead of the raw diff.

Here’s a real one. I asked the agent to show me a caching change instead of describing it

  on(save)
-   write content
+   if content is unchanged
+     return cached result
+   write new content
+   invalidate cache

Five lines, and the whole behavior change is visible. You can see the early return, the new write, and the invalidation that has to follow it. That last line is exactly the kind of thing that gets buried in a paragraph and skipped in a source diff.

It also seems to me that having to show the solution makes the agent think it through more carefully, even when I don’t ask for changes.

Show Me is one small piece of HumanLayer’s broader approach. Look at the HumanLayer blog to learn more about these ideas.

Poteto Mode and verification

Lauren Tan, known online as @poteto, leads development of GrokBot and says she merges a thousand-plus PRs with this workflow. She frames verification as one of the most important things in your toolbox in The Complete Guide to pstack, Part 1.

Her broader Poteto Mode is part of pstack, an open-source Cursor plugin for rigorous engineering and verification. Its verification skill teaches agents how to drive and inspect the real product.

I like how seriously Lauren frames verification: an agent saying the tests pass is not proof that the product works. Poteto Mode makes verification reusable infrastructure by teaching the agent how to open the app, drive its important workflows, inspect the result, and show evidence.

Once that exists, every task can end with a real product check. That makes autonomous work easier to trust and saves the back-and-forth after an agent says it is done.

The pstack guide goes much deeper into composing verification with playbooks, independent reviewers, parallel agents, and longer autonomous work.

Building trust with AI output

I think of these as alignment tools as much as productivity tools. The alignment is what makes the productivity compound: a misaligned agent working faster just produces more of the wrong thing, and that cost compounds too. These skills bring human judgment and taste into the workflow: clarify what you want, make the approach visible, and verify the result.

You still have to look at the code. But when you do, there are fewer surprises, and that is what lets you leave an agent alone for longer.

This is just the tip of the iceberg.

If you want to learn more, or your organization needs coaching or enablement to help teams actually use these skills, email luke.otwell@softlandia.com or visit softlandia.com.

If you’re interested in these ideas, check out Applied AI engineer and Making agent guidance automatic and cheap.

‍