Garbage In, Garbage Out: Building a Blog Writer SKILL for Consistent AI Outputs
How I encoded my writing DNA, engineering philosophy, and structural rules into a reusable agent SKILL file so every AI-generated blog post actually sounds like me.
I’ve been writing about engineering for years. The style, the voice, the phrasing — it’s mine. But every time I asked an AI to write a blog post “in my style,” I got something that technically covered the topic but felt like a Wikipedia article written by a consultant. Technically correct. Completely soulless.
The problem wasn’t the AI. The problem was my input. Garbage in, garbage out — the oldest rule in computing applies to prompt engineering just as hard as it does to data pipelines.
Here’s how I fixed it by building a dedicated blog writer SKILL file for my agent workspace.
The Problem with Vague Style Prompts
“Write in my style” is not an instruction. It’s a wishful thought.
I had two detailed documents sitting in my project’s docs/ directory:
- Writing Style DNA Analysis — a breakdown of my four writing personas: Scholar, Leader, Senior Engineer, and Passionate Mentor. It covers tone, diction, pacing, and specific signature phrases.
- Coding Style Analysis — my engineering philosophy: defensive programming, architectural patterns, naming conventions, production-readiness mindset.
These were gold. But without a structured way to surface them to the agent at the start of every task, they were just… files. The agent would write a post, I’d spot something off, paste in the style guide, get a revised draft that was better but still not quite right. Inconsistent. Unreliable.
What I needed was a SKILL file — a compact, structured instruction set that activates automatically whenever a blog post is requested.
What a SKILL File Actually Is
In the Antigravity agent workspace, a SKILL is a directory under .agents/skills/<skill-name>/ containing a SKILL.md file. The frontmatter declares the name and description — which the agent uses to match the skill to incoming task types. The body is loaded as binding instructions once the skill is activated.
.agents/
└── skills/
└── k007sam-blog-writer/
└── SKILL.md
The SKILL file becomes the pre-execution contract for every blog post. The agent reads it before writing a single word.
What Goes Into the SKILL
Getting the structure right took two iterations. Here’s what the final version covers:
1. Persona Declaration
I declared the two active personas and what each one means concretely:
The Passionate Mentor — direct address, informal enthusiasm, personal anecdotes, genuine excitement. Signature phrases like “Lo and behold!”, “Here’s the real story…”, “fellow builders.”
The Senior Engineer — assumes expertise, precise domain language (WebRTC ICE candidates, AOSP Treble, event-driven pub/sub), architectural rationale for every code decision, production-context framing.
The hybrid of both personas is what makes the writing mine.
2. Hard Anti-Patterns
This was the most important section to write explicitly. I listed the patterns that AI reliably falls into that instantly break the voice:
- “In today’s fast-paced digital world…” — kill on sight.
- “This blog post will cover…” — meta-narration. Start with the problem.
- Over-hedging (“it might be worth considering”) — I don’t hedge. I decide and explain why.
- “In conclusion, we learned…” — replace with a tight, energetic takeaway.
Listing these explicitly does more work than describing what I want — because the agent already knows what good writing looks like. What it needs is the constraint set that defines my version of good.
3. Frontmatter Schema
The Astro content collection has a strict schema. Every post needs:
---
title: "Punchy, Specific Title"
date: YYYY-MM-DD
description: "One high-impact sentence."
tags: ["astro", "devlog", "ai-development"]
draft: false
---
Having this in the SKILL file means I never get a post with missing frontmatter or an invalid schema that breaks the build.
4. Structural Blueprint
I defined the four required sections in order:
- The Hook — real, honest, personal. Not a generic intro.
- The Hard Constraints — 2–4 non-negotiable architectural decisions.
- Implementation Beats — numbered sections with code blocks and architectural rationale.
- The Takeaway — tight, energetic, not a summary.
The blueprint isn’t restrictive — it’s a scaffold. The content fills it, but the shape is consistent across every post.
5. Pre-Execution Checklist
Before the agent outputs anything, it checks:
- Is frontmatter complete and valid?
- Does the hook open with a real problem, not a generic sentence?
- Are anti-patterns avoided?
- Does every code block have a language tag and a “why” explanation?
- Is the final section energetic, not a recap?
This is the difference between “write a blog post” and “write a blog post that passes QA.”
The Coding Philosophy Table
I added a reference table that maps my engineering principles to how they should appear in writing:
| Principle | How to Reflect It |
|---|---|
| Defensive Programming | Show guard clauses, null checks, input validation in code examples |
| Architectural Excellence | Call out clean abstractions, event-driven decoupling, DI patterns |
| Teaching Code | Treat code blocks as primary content — surround with “why”, not just “what” |
| Production-Ready | Anchor decisions in deployment reality (Docker, memory, cold starts) |
This bridges the gap between the two documents — the writing style guide and the engineering philosophy — and synthesizes them into actionable content directives.
The Result
The first blog post written with the full SKILL file active was the session synthesis article covering the modal architecture, audio continuity fixes, and project brief extraction we built that same day.
The difference was immediate. The opening hook was personal. The code blocks had rationale. The takeaway didn’t start with “In summary.” The voice was recognizably mine.
The lesson isn’t about AI prompting. It’s about the same principle that governs any software system: invest in your input quality, and your output quality follows. The SKILL file is the schema validation layer for my blog. Define the contract precisely once, and the system honors it every time.
Now every time I ask the agent to write a post for k007sam.com, it loads the SKILL, reads the constraints, runs the checklist, and produces something that sounds like a human engineer who cares deeply about what they’re building — because that’s what I encoded.
Garbage in, garbage out. Clean contract in, clean output out.