Kilo Code Agent Skills and the Space Between AI Hype and Reality

Agent Skills: A Lightweight Format for Extending AI Coding Agents

TLDR: Kilo Code introduces Agent Skills — a simple, open format for packaging domain expertise and workflows that AI agents can use on demand. It's basically a SKILL.md file with YAML frontmatter and markdown instructions that agents load when tasks match specific patterns.

Summary:

Here's something genuinely useful for teams working with AI coding agents: a standardized way to teach them new tricks without retraining models or writing complex plugins. Kilo Code's Agent Skills are essentially markdown files that contain instructions an AI agent reads when it encounters matching tasks.

The architecture is refreshingly simple. You create a folder with a SKILL.md file containing YAML frontmatter (name, description) and markdown instructions. The agent discovers these skills at initialization, matches them to the current task context, and loads relevant instructions into its system prompt. No API integrations, no complex configuration — just files in predictable locations.

Skills can be global (stored in ~/.kilocode/skills/) or project-specific (.kilocode/skills/ in your repo), and they can be mode-specific. So you might have a skill for API design that only activates in Architect mode, or a TypeScript patterns skill that only loads in Code mode. The priority system is sensible: project skills override global skills, mode-specific override generic.

For architects and team leads, this is a practical mechanism for encoding institutional knowledge. Think about onboarding — instead of hoping a new developer reads the coding standards document, you encode those standards as skills that the AI agent actively applies. The agent becomes a vector for consistent practices across the team. You could have skills for your company's API conventions, testing patterns, security requirements, or deployment procedures.

The interoperability angle is worth noting too. Skills follow an open specification, so theoretically they could work across different AI coding tools. Whether that cross-tool compatibility materializes depends on adoption, but the format is simple enough that it should be portable.

Key takeaways:

• Agent Skills are markdown files (SKILL.md) with YAML frontmatter that extend AI agent capabilities
• Skills can be global, project-specific, and mode-specific with a clear priority hierarchy
• The format is designed to be self-documenting, shareable, and interoperable across tools
• Skills can bundle additional resources like scripts, templates, and reference documentation

Tradeoffs:

• Gain standardized, portable agent extensions but sacrifice deep integration with specific AI providers
• Encode team knowledge in skills but must maintain them as practices evolve

Link: Skills | Kilo Code Docs

The Space Between AI Hype and AI Denial

TLDR: AI coding tools have crossed a productivity threshold — the data shows 76% output increase year-over-year — but the conversation is poisoned by two years of failed "developers will be obsolete" predictions. The answer isn't fear or denial, it's curiosity.

Summary:

Brendan O'Leary from Kilo writes what might be the most balanced take on AI coding tools I've read in months. He acknowledges something important: the AI companies themselves have made honest conversation nearly impossible by spending two years predicting software engineers would be obsolete "within six months" or "by 2025." That didn't happen. Engineers are still here, still employed, and the major AI labs themselves are hiring more engineers.

But here's where O'Leary doesn't let the skeptics off the hook either. Just because the hype merchants were wrong about the timeline doesn't mean the underlying tools are useless. This is a pattern we've seen before — Git zealots were insufferable, Docker evangelists promised containers would solve world hunger, DevOps consultants were over-the-top. The hype was annoying and often wrong about magnitude and timing. But Git actually was better than SVN for most workflows. Containers actually did transform deployment.

The data he presents is compelling. Greptile's State of AI Coding 2025 report shows developer output up 76% year-over-year. Lines of code per developer grew from 4,450 to 7,839. Median PR size increased 33%. Meanwhile, Stack Overflow question volume has collapsed — developers are asking their questions to AI instead of posting and waiting to be told it's a duplicate.

What makes AI different from previous tool transitions is the non-deterministic nature. The same prompt doesn't always give you the same output. The model might nail it or hallucinate nonsense. O'Leary frames this well: working effectively with AI is less like learning a new programming language and more like learning to work with a very fast, very well-read, somewhat unreliable junior developer. The mental models, feedback loops, and failure modes are different.

For architects and senior engineers, this reframing is important. The question isn't "Will AI replace me?" — it's "How do I use AI as a multiplier for my engineering work?" Answering that well requires treating this as a new skill to develop, not just a plugin to install. The senior engineers O'Leary respects most are using these tools daily. If you tried them in 2024 and wrote them off, your experience is outdated.

Key takeaways:

• Two years of failed "obsolescence" predictions have created a trust deficit that makes honest AI conversation difficult
• Data shows real productivity gains: 76% output increase, lines of code up from 4,450 to 7,839 per developer
• AI is non-deterministic, so working with it requires new mental models unlike learning a typical new framework
• Historical pattern repeats: hype merchants were wrong about timing but underlying tools were genuinely useful

Tradeoffs:

• Gain significant productivity multiplier but sacrifice predictable, deterministic tool behavior
• Embrace AI tools early but invest time developing new mental models and feedback loops

Link: The Space Between AI Hype and AI Denial

Kilo Code: The Open Source Coding Agent Platform

TLDR: Kilo Code is an open-source VS Code extension providing AI coding assistance with 500+ models, transparent pricing at exact provider rates, and multi-mode workflows for architecture, coding, and debugging.

Summary:

Looking at what Kilo is actually offering here: it's a VS Code extension (also coming to JetBrains and CLI) that provides AI coding assistance with some notable architectural decisions. First, it's fully open source under Apache 2.0, so you can actually inspect what's happening with your code and prompts — no silent context compression or hidden model selection.

The model flexibility is significant. You can use 500+ models from various providers at exact provider rates with no commission. That's a different business model from competitors who add markup. They make money on Teams/Enterprise features instead. You can also bring your own API keys or run models locally via Ollama or LM Studio.

The multi-mode concept is interesting for complex workflows. You can plan with Architect mode, implement with Coder mode, and debug with Debugger mode. Each mode presumably optimizes the prompts and tool access for that phase of work. Plus you can create custom modes, which ties back nicely to the Agent Skills system.

For teams evaluating AI coding tools, the open source nature addresses legitimate concerns about black box behavior. You can see exactly what context is sent, what the full prompts look like, and audit the behavior. The stats they're quoting are impressive: #1 on OpenRouter, 750k+ users, 6.1 trillion tokens per month. Whether those numbers translate to your use case depends on your stack and workflow, but it suggests the tool has crossed a viability threshold.

Key takeaways:

• Open source Apache 2.0 license with full visibility into prompts and context handling
• 500+ models with transparent pricing at exact provider rates (no markup)
• Multi-mode workflow: Architect, Coder, Debugger plus custom modes
• Supports BYOK and local models via Ollama/LM Studio

Link: Kilo Code on GitHub