I'm cautiously optimistic about AI tools, not as replacements for critical thinking skills, judgement calls, and real-life expertise, but as remarkable automation tools in a well-structured workflow.
These are my most used skills on a daily basis:
- 01Critique An AI reviewer that remembers what it found last time
- 02Handoff A structured record of decisions, state, and unfinished work
- 03Retrospective Turning workflow history into lessons and next actions
- 04Token-aware Measuring AI effort and cost instead of guessing
- 05KB-search Making prior decisions and artefacts findable
(Retrospective, Token-aware, and KB-search links go live once each post is published.)
I didn't start off being too keen on LLMs. I was unimpressed by earlier versions of popular tools, automatic completions would more often than not miss the whole nail, let alone its head, and the video of Will Smith eating spaghetti was incredibly uncanny. Those early experiences failed to inspire an urge to be an early adopter of what was, at the time, novelty over-engineering piled onto already complex and tangled systems. Besides, was there a question Stack Overflow couldn't really answer?
That assumption did not age as well as I expected.
What changed
Still, nothing ever really stays the same. Those LLMs were far from stagnant with models continuously improving, outgrowing teething pains catalyzing compounding competition of capacity and competence. At the same time, I started reading more about skills that enabled longer context, tooling, defining proper processes, and implementations of multi-step tasks with evaluations, making even skeptics like me finally take the plunge. And oh, were the waters nice.
The solo-work problem
Working on my own projects at home I missed the back-and-forth with others and learning from their varied experiences and perspectives, a privilege I've had in the teams I was lucky to be part of. Though not a shoo-in, in lieu of fellow humans other than the occasional friend-turned-rubber-duck, a well-defined skill just might bridge some of the gap.
In practice, that means bringing:
- A clear role and scope.
- A repeatable process.
- Explicit checks and constraints.
- Relevant reference material.
- A durable record of prior work.
- Permission to challenge an assumption rather than merely agree.
Existing tools, and why I built my own
I set out into the world (wide web) to try existing skills on for size. Most have come and gone, others like GSD-core and Graphify are here to stay, yet none were quite tailored for me.
Ultimately, I had to review my own routines, preferences, common prompts, requests, and complaints before it became clear what I actually needed. I built skills that ousted the unnecessary, vapid congratulatory tone in favour of honest and challenging pushback, the kind that helps me improve with actual, factual feedback. Specifically, I wanted skills that would:
- Challenge unclear reasoning.
- Preserve context across sessions.
- Surface weak evidence.
- Make effort and cost visible.
- Separate a proposed change from a solved problem.
A caveat before we start
I'm not a complete convert, nor an AI maximalist. Every so often there's a new trend sweeping the tech nation, proclaimed to be the new panacea. When inevitably the tide of hype goes out, it becomes clear how much of the significant progress is diluted by the excitement of novelty.
In this case, I view AI and LLMs in particular similarly to how I approach cars and statistics. The more a given tool is complex, with ever-escalating consequences, the more it requires a person to understand what's going on under the hood and apply their judgement in evaluating the results. Otherwise, we might find ourselves muttering "Lies, damn lies, and Generative AI."
Next
Technical detail: where these skills live
Each of the five skills referenced in this series is a self-contained Claude skill: a protocol file plus, for the arithmetic parts of the job, a small Python toolkit. They live together in one repository, versioned and installable independently of each other. The posts that follow each cover one skill's mechanism, a real run, its design decisions, and its limits, with a technical appendix like this one underneath for anyone who wants the schema, the file layout, or the exact rules.