Scalable Human Blog

TL;DR: The three AI agent skills that have had the biggest impact on my personal projects are grill-me, caveman and thermo-nuclear-code-quality-review. Each improves a different part of the development process: thinking clearly, building quickly and reviewing code more rigorously.

Over the past few months, I have been experimenting with reusable AI agent skills across my personal software projects.

The biggest lesson has not been that AI agents need to be “smarter” in some general sense. It is that they become far more useful when their behaviour is shaped for the task at hand.

Sometimes I want the agent to challenge me. Sometimes I want it to stop talking and just get on with the work. Sometimes I want it to be brutally strict about code quality.

The three skills that have helped me most are:

• grill-me
• caveman
• thermo-nuclear-code-quality-review

They map neatly onto three stages of software development:

Question the plan → build efficiently → review rigorously

But they also come with trade offs. Their weaknesses are often extensions of their strengths.

1. grill-me: Better thinking before building

grill-me is most useful before implementation begins.

The idea behind the grill me skill is simple: instead of letting the AI agent immediately turn an idea into code, it pushes the agent to question the proposal first.

That makes it especially useful for personal projects.

When you are working alone, there may be no product owner, architect or second engineer to challenge your thinking. An idea can feel complete in your head while still hiding important gaps.

For example, you might know what you want the app to do, but not yet have clear answers to questions like:

• How should the data be stored?
• What happens if an external service is unavailable?
• How should errors be shown to the user?
• Which settings should be configurable?
• What happens when two requirements conflict?
• Which features are essential and which are optional?

grill-me acts like a technical interviewer. It forces vague intentions to become explicit decisions.

Why it helps

Used well, grill-me can:

• Expose missing requirements early
• Challenge weak assumptions
• Identify edge cases before they become bugs
• Force architectural choices to be justified
• Turn a loose idea into a realistic implementation plan
• Replace some of the challenge you would normally get from another engineer

This can save a lot of time. It is much cheaper to discover a design problem before writing hundreds of lines of code.

Where it can go wrong

The downside is that questioning can become indecision.

Not every uncertainty needs to be solved before coding starts. Some answers only become clear once you build a prototype and see how the idea behaves in practice.

A small local dashboard does not need the same level of requirements analysis as a regulated production service.

So I try to use grill-me to remove dangerous ambiguity, not every possible unknown.

The goal is not a perfect plan. The goal is a plan good enough to start building with confidence.

2. caveman: Faster feedback while building

AI coding agents can be extremely verbose.

They often repeat the task, explain obvious changes, describe every file they edited and finish with a long summary of work that is already visible in the diff.

That can be useful when you are learning. But during routine development, it can slow the rhythm down.

The caveman skill pushes the agent toward a much more direct communication style.

For an experienced developer, this can make the interaction feel less like waiting for a written report and more like working through a fast engineering loop.

Most of the time, I do not need several paragraphs explaining that a function was renamed or a test was added. I need to know:

• What changed
• Whether it worked
• Whether tests passed
• What assumptions were made
• Whether the agent needs a decision from me

That is it.

Why it helps

caveman is useful because it can:

• Remove conversational filler
• Reduce repeated explanations
• Make important warnings easier to spot
• Reduce output token usage
• Speed up frequent interactions
• Keep the focus on implementation rather than commentary

It works best when I already understand the codebase and do not need the agent to teach me every concept involved.

In that situation, short answers are not rude. They are efficient.

Where it can go wrong

Conciseness can remove useful context as well as unnecessary context.

A compressed response might say something failed without explaining why. It might hide trade offs, assumptions or uncertainty that should be discussed.

That matters when I am:

• Learning an unfamiliar technology
• Investigating a difficult bug
• Reviewing an architectural decision
• Working with security sensitive code
• Trying to understand why the agent chose one approach over another

There is also a risk of confusing short output with better engineering.

Fewer words do not automatically mean better code.

For me, caveman is best during routine development and iteration. When the work becomes subtle, risky or unfamiliar, I either disable it or explicitly ask for a deeper explanation.

3. thermo-nuclear-code-quality-review: A stricter final check

thermo-nuclear-code-quality-review is the most intense of the three.

The Cursor team kit skill is designed to apply a very demanding review standard to implementation quality, maintainability and overall codebase health.

The dramatic name fits.

This is not a light pass for formatting issues. It looks for deeper structural problems, such as:

• Files with too many responsibilities
• Conditional logic that keeps growing
• Logic placed in the wrong layer
• Weak type boundaries
• Unnecessary wrappers
• Duplicated helpers
• Abstractions that add indirection without simplifying the code
• Refactors that move complexity instead of removing it
• Features that work, but leave the surrounding codebase worse

One idea I particularly like is the search for a “code judo” move.

That means looking for a restructuring that preserves the required behaviour while making the implementation dramatically simpler.

Instead of just reorganising branches and helper functions, the review asks whether the design can change so that some of those branches, modes or helpers disappear entirely.

That distinction matters.

The skill does not only ask, “Does this code work?”

It asks, “Has this code left the codebase healthier?”

Why it helps

AI generated code can satisfy an immediate requirement very quickly.

That speed is useful, but it can also encourage developers to accept the first version that passes tests. The code may work while still introducing duplication, vague responsibilities, weak abstractions or confusing control flow.

thermo-nuclear-code-quality-review pushes back against that.

It can help:

• Find maintainability problems that tests may not reveal
• Challenge weak or unnecessary abstractions
• Detect misplaced responsibilities
• Encourage clearer architectural boundaries
• Improve type safety and data contracts
• Reduce duplicated or scattered logic
• Push for simpler implementations, not just reorganised ones
• Provide a demanding second review of a large AI generated change

This is especially valuable in software where reliability and maintenance matter.

For example:

• Financial software
• Security sensitive systems
• Business critical services
• Shared production codebases
• Software maintained by multiple engineers
• Large architectural changes

In those environments, understanding why the code behaves as it does can be just as important as confirming that it works today.

Where it can go wrong

The main drawback is also the point of the skill: it is deliberately strict.

That can be excellent in a mature production system, but disproportionate in a prototype or small personal project.

It may encourage you to:

• Split files before the split adds real value
• Add architectural boundaries too early
• Rework functioning code to remove minor branching
• Replace a simple local solution with a broader structural change
• Add tests for scenarios that are unlikely to happen
• Spend too long searching for the most elegant implementation
• Delay delivery for maintainability concerns that may never matter

Those recommendations may improve theoretical quality, but engineering quality is not the only constraint.

Time matters. Delivery speed matters. Uncertainty matters. The expected lifespan of the code matters.

If I am building a personal product quickly, the immediate goal may be to learn whether the idea is useful. Perfecting code that may be deleted next week is not always a good trade.

So I treat this skill as a demanding senior reviewer, not an unquestionable gatekeeper.

A useful priority order is:

1. Fix correctness, security and data integrity problems.
2. Address structural issues that will clearly affect future maintenance.
3. Apply improvements that genuinely simplify the implementation.
4. Defer speculative abstractions and low impact style concerns.
5. Reject recommendations that add more complexity than they remove.

The skill should make the strongest possible case for improving the code. The developer still has to decide what is proportionate.

How the three skills work together

These skills are most useful when applied at different points in the project.

grill-me belongs at the start

It helps me challenge the idea before I commit to an implementation.

It is best for:

• Planning a new feature
• Clarifying vague requirements
• Surfacing edge cases
• Testing assumptions
• Choosing between possible designs

caveman belongs in the build loop

It keeps interactions fast and focused.

It is best for:

• Small implementation tasks
• Routine refactors
• Test fixes
• Iterative changes
• Work in codebases I already understand

thermo-nuclear-code-quality-review belongs at review checkpoints

It is best used after meaningful work has been completed.

It is useful when:

• A feature is ready for review
• A large AI generated change needs scrutiny
• An architectural change has been made
• Code is moving from prototype quality toward production quality
• Long term maintainability matters

Together, they create a balanced workflow:

Question the idea. Build with focus. Review with discipline.

The important part is adjusting the intensity.

A prototype needs enough planning to avoid obvious mistakes, enough speed to validate the idea and enough review to prevent serious failures.

A professional or regulated system needs more. It justifies deeper requirements analysis, stronger boundaries, clearer documentation, broader testing and a stricter final review.

Key Takeaways

• Use grill-me before coding to expose missing requirements, weak assumptions and unclear decisions.
• Use caveman during routine development when you want faster, more focused AI agent interactions.
• Use thermo-nuclear-code-quality-review at review checkpoints to challenge maintainability, structure and code health.
• Do not let any skill run the project by default. Match the skill to the maturity, risk and purpose of the work.
• The weakness of each skill mirrors its strength: questioning can become indecision, brevity can hide context and strict review can become over engineering.

Conclusion

The biggest benefit of reusable AI skills is not that they make an agent universally better.

They let you deliberately change how the agent behaves at different stages of the engineering process.

grill-me helps me think more clearly before implementation.

caveman helps me move faster while building.

thermo-nuclear-code-quality-review stops speed from becoming an excuse for weak engineering.

Used together, they make my personal projects feel more deliberate and more controlled. But the real skill is knowing when to use each one, how strongly to apply it and when to say, “This is good enough for what I am building right now.”

📚 Further Reading & Related Topics
If you’re exploring AI agent skills for personal projects, these related articles will provide deeper insights:

• Unlocking AI Driven Coding With Agentic Mode In Cursor IDE : Explores how Cursor IDE agentic mode can help developers delegate coding tasks, iterate faster, and build more effectively with AI assistance.

• Mastering ChatGPT Prompt Frameworks : A strong companion for understanding how better prompting improves AI agent output, especially when guiding tools through planning, debugging, and implementation work.

• How To Optimize Cursor Usage With Cursorrules Files : Shows how project specific rules can make AI coding agents more consistent, which is highly relevant when using agents across personal projects.