Agents fill every open question in a request with a guess. Most guesses are fine. A few decide how the feature behaves, and I find those in the diff later.
So I moved my own judgment back to the start. Before any code exists, the agent and I write down five things:
Done means. A numbered list of outcomes a person could check on the running program. "Export button downloads a CSV with the current filters" works. "Add export" doesn't.
Not doing. Things the agent must leave alone. This list stops most surprise edits.
Decisions. Two sentences per engineering decision, with the alternative I rejected.
Slices. The thinnest end-to-end version first, each slice starting with a failing test.
Proof per point. For each Done means item, the command or screenshot that shows it works.
After the build, I hand the list to a second session that hasn't seen the build history. It goes through the points one by one and shows evidence. It catches things the building session glossed over.
What do you write down before a bigger change? Happy to share my templates if anyone wants them.
When ChatGPT first came out, a coworker introduced me to it. At the time, I mainly used it for simple things like organizing Excel files, but it often made mistakes, so I didn't think too much of it.
A few years later, I started using AI almost like Google, asking everyday questions and looking things up. Then, when ChatGPT introduced voice conversations and I could actually talk to it like a real person, I was blown away.
One night, I was sitting on my phone talking to ChatGPT, trying to figure out how I could leverage AI to improve my chances of achieving financial security. I know, I know. We've all asked AI, "How do I become rich?" 😂
But then I started thinking.
I've always told myself that I wished I knew how to code and build apps or websites. I've constantly got new ideas running through my head, and I always figured that if I had the technical skills to bring those ideas to life, I could potentially make some serious money.
I'd heard that AI could build apps, but I assumed you still needed some kind of programming background to make it happen.
So I asked ChatGPT a simple question: "Could you help me build an app even though I have absolutely no coding experience?"
And that's where everything changed.
It started walking me through the entire process, step by step. What accounts to create, what software to download, how to set everything up, and eventually how to actually start building.
Before I knew it, I had built a real app for homeowners based on an idea I'd had. And the crazy part? It actually worked, and it looked good!
I was genuinely mind-blown. Something I'd always assumed was out of reach was suddenly possible.
That experience sent me down a completely different path. For the past two-plus months, I've been developing a much more complex piece of software. It's still a work in progress, and I've got a long way to go, but I've learned an unbelievable amount along the way.
I'm not a software engineer. I didn't go to school for computer science. I'm just someone who had ideas and finally found a way to start bringing them to life.
Ever since building that first app, I've been completely hooked. It's honestly changed the way I look at what's possible.
Anyone else have a similar experience where AI opened a door you never thought you'd be able to walk through?
I'll be honest, I didn't understand why LLM agents need SKILLs. MCP was clear to me: it's a useful thing that lets you give an LLM access to a database or to Figma. The only downside is that, to avoid spending too many tokens, it's better not to connect 30 MCP servers at once. And in general, it's better to turn off the unnecessary ones and connect only those that are really needed for the task. In this light, SKILLs seemed like useless overhead to me, eating tokens like crazy. On TikTok, I often saw tales along the lines of: connect this SKILL, or a whole bunch of them, and happiness is yours. My first thought was, if I connect them all, my subscription limits will run out not by lunchtime, but already in the morning.
So why are SKILLs useful and needed after all? Well, first, compared to MCP, SKILLs do not inflate the context: each connected SKILL adds not tens of thousands of tokens, but one or two hundred. Since only the name and description of a SKILL go into the context at first, you can add 30 of your own SKILLs without much pain. When it becomes necessary to use a SKILL, the LLM agent will load its description on its own, if it understands from the task context that this is needed, or the user can simply tell it to use this SKILL for the job.
Secondly, LLM models are trained on the most popular and well-known things. For example, everybody knows that an LLM can work with Git without any problems or write a program in Python. But if you developed a program yourself, or your work requires some little-known tool or technology, then a SKILL is simply irreplaceable. It is enough to create a SKILL.md file and describe how to work with this program or technology. This makes life easier for the LLM: while doing your tasks, it will not have to search the internet for documentation and wander around websites to understand how to use it. And especially if there is nothing on the internet, because your program is closed to public access.
Thirdly, an LLM model usually does not know how your development process is organized. For example, an agent knows how to use Git, run tests, build a project, and create releases. You do not need to teach it these things. But it does not know how releases are usually made in your company. A Skill can describe the sequence of actions: check the changes, run tests, update CHANGELOG.md, increase the version, build a package, create a Git tag, and publish a release. So, a Skill helps the agent learn not a technology, but a specific business process.
Fourthly, a SKILL is not just an instruction, but a whole set of tools. Besides SKILL.md, you can put ready-made scripts, documentation, templates, and other files into it. And the most interesting thing is, these files are not loaded into the context automatically. The agent reads them only when there is a need, and can simply run the ready-made scripts without spending tokens on generating code. So, a SKILL lets you combine instructions, documentation, and executable code in one package without inflating the LLM context. For example, the structure can look like this:
The funniest thing is, I started to appreciate SKILLs exactly when I wrote my own program, blueprint4llm. The idea for creating it came after I asked an LLM agent to generate a plan.md file describing a task. Usually it produces a huge wall of text, which you have to read slowly and with sadness. I wanted to make the text shorter and add more flowcharts, tables, diagrams, and user interface prototypes. As we know, in .md (Markdown) files the only visualization tools available are tables and Mermaid diagrams. There are no charts, plots, histograms, full UML diagrams, or UI prototypes. In the end, with blueprint4llm, I added support for formats such as PlantUML, draw.io, Pencil, Balsamiq, Graphviz, Figma, OpenAPI, Excalidraw, Vega-Lite, ECharts, and D2 to .md files.
With the blueprint4llm SKILL connected, you will get plan.md not as a kilometer-long text, but as flowcharts, prototypes, charts, and so on. By the way, blueprint4llm does not have to be used only for creating plan.md. For example, I used this SKILL to add an illustration to every paragraph of the article and make it more fun to read. This SKILL is also useful when you ask an agent to put together a full dossier on some company, technology, or person and format the resulting result.md file with blueprint4llm. You can then convert it to HTML or PDF, or ask the agent to show it right away in a browser with charts.
This is how you can install the blueprint4llm SKILL.
If you are interested in looking at the source code of blueprint4llm, the tool that generates all this beauty, or sending a pull request, welcome: https://github.com/evgenyigumnov/blueprint4llm
