Skill Issue: Level Up Your AI Agents

Hey everyone! Welcome to the AI Cebu Community event here at Zero-Ten Park. My name is David Panonce — I'm an Agentic Systems Architect and Co-founder and CTO at FrontierAI Works.

Today we're going to talk about something every developer using AI agents has run into — but most don't have a name for. Your agent is smart. It has access to tools. But it keeps failing at specific tasks. It hallucinates file paths. It picks the wrong tool. It burns through your context window before doing anything useful.

The community has a word for this: skill issue.

(pause for laughs)

And today, I'm going to show you how to literally fix that — by giving your agents actual skills.

Let's start with the root problem.

AI agents are incredibly capable — but they're generic. Out of the box, they don't know your codebase, your team's conventions, your deployment pipeline, or your product's domain language.

So what do developers do? They register tools. Lots of tools. "Here's a tool for database queries, here's one for file search, here's one for Slack, here's one for Jira..." Before you know it, you've got 40 tools loaded into your agent.

Here's the problem with that: 40 tools means 10,000 to 15,000 tokens are burned just on tool descriptions — before the conversation even starts. That's your context window being eaten alive.

And it gets worse. When descriptions are vague or overlapping, the LLM gets confused. It picks the wrong tool, retries, picks another wrong tool, and exhausts its iteration budget doing nothing useful.

This is what I call context window pollution. Your agent is drowning in its own instruction manuals.

So how do we fix this? Enter: Agent Skills.

A skill is a reusable set of instructions that teaches an AI agent how to do a specific task well. Think of it as a playbook — not a tool, not a plugin — a playbook.

Originally developed by Anthropic and released as an open standard, skills are now supported by Claude Code, VS Code, Cursor, and more.

And here's the beautiful part — at its simplest, a skill is just a directory containing a single file: SKILL.md. That file has a name, a description, and instructions. That's it. No SDK to install, no API to integrate. Just markdown.

(let that sink in — "just markdown" should feel like a relief)

Now you might be thinking: "Okay, but if I have 40 skills instead of 40 tools, isn't that the same problem?"

Great question. And the answer is no — because skills use a concept called progressive disclosure. This is the secret weapon.

There are three levels.

Level 1 — Discovery. At startup, the agent only loads the skill's name and description. About 100 words. It uses this to know when a skill might be relevant. Tiny footprint.

Level 2 — Activation. When a user's prompt matches the description, then the agent loads the full SKILL.md body into context. Ideally under 500 lines.

Level 3 — Execution. Only when the agent is actually doing the work does it pull in additional scripts, templates, or assets.

So instead of loading everything upfront, you load what you need, when you need it. This is how you scale to hundreds of skills without killing your context window.

Another thing I love about skills: they're portable.

While skills are typically just folders on a disk, modern implementations — like the Agent Skills SDK for Python — treat skills as abstract units of expertise. The SDK doesn't care where the skill lives.

Today it's a local filesystem. Tomorrow it's an S3 bucket. Next week it's Azure Blob Storage or a database. Your skills are decoupled from your infrastructure.

This matters because it means teams can share skills across projects, across repos, across entire organizations — without being locked into one storage provider.

Now let me show you what a real skill system looks like at scale. This is Chalk Skills — an open-source, opinionated stack of 78 skills for AI-powered product development.

(pause — let "78" land)

Not 7. Not 12. Seventy-eight skills covering the entire product lifecycle.

Product strategy skills — create-prd, create-roadmap, create-jtbd-canvas, create-gtm-brief, create-user-stories. Your agent can draft a product requirements document or a go-to-market brief that follows your team's exact format.

Engineering skills — create-adr for architecture decision records, debug-systematic for structured debugging, audit-security for threat modeling, create-release-checklist, create-rollback-plan. The kind of stuff senior engineers do that nobody writes down.

Framework-specific patterns — Next.js app router patterns, React component patterns, Flutter state management, FastAPI endpoint patterns, Python clean architecture. Your agent writes code that matches the idioms of your stack.

A full review pipeline — handoff, review, fix findings — five skills chained together.

And documentation skills that bootstrap, create, and update docs across product, engineering, AI, and design verticals.

Every skill has versioned frontmatter with SemVer, ownership metadata, allowed tools, and risk levels. This isn't a collection of scripts. It's a system.

We also shipped Chalk Skills as a VS Code extension on Open VSX. And it hit 338 downloads.

(pause — let the number land)

Zero marketing. No Product Hunt launch. No Twitter thread. Developers found it and installed it because the problem is real.

The extension gives you a gamified interface for discovering, crafting, and managing skills right inside your editor. It works with Claude Code, Cursor, and any agent that reads SKILL.md files.

That organic adoption validated something for us — developers don't just want AI agents. They want a way to make those agents actually good at their specific workflows. That's the gap skills fill.

Now let me show you how this actually works under the hood — because this is where it gets technical and interesting.

The extension runs in three phases.

Phase 1 — Discovery. On activation, it scans your workspace for SKILL.md files and parses their YAML frontmatter — name, description, risk level, allowed tools, capabilities. If your workspace has no skills, it falls back to 78 bundled skills that ship with the extension. Workspace skills always take priority.

(pause)

Phase 2 — Classification. Every skill gets automatically assigned to a software development phase: Foundation, Design, Architecture, Engineering, Development, or Launch. This happens through a multi-pass classifier — it checks a manual index, then name prefixes, then runs TF-IDF cosine similarity against phase descriptions, then keyword scoring, then artifact glob patterns. The result? An automatic skill tree. You don't configure it. It builds itself.

(pause)

Phase 3 — Interaction. When an agent reads a SKILL.md or modifies a matching file pattern — like any test file — the auto-recorder fires. It awards XP based on risk level, tracks discovery bonuses for first use, computes skill levels from Novice to Master, and checks 12 achievements. All rendered in a React webview with Framer Motion animations.

And the killer feature for agents: context injection. Skills can declare needs like git-status, diagnostics, or test-results. The extension runs 6 parallel context collectors and assembles workspace-aware context automatically. The agent gets everything it needs without manual copy-paste.

Let me show you a real skill in action — the commit skill. It's one of the simplest in Chalk Skills, and it's the perfect example of what a skill actually does.

You finish writing code and just say "commit my changes." The agent looks at its skills, matches that to the commit skill, and activates it. You can also invoke it directly with /commit. Either way, here's what happens.

(pause)

The skill checks git status and git diff to understand what changed. It analyzes whether your changes are related or should be split into granular commits. Then it stages specific files — and this is important — it never uses "git add dot" or "git add -A." Always explicit file staging.

(pause)

Next, it drafts a conventional commit message — feat, fix, refactor, docs — with the right scope and a description that explains the why, not the what. Subject line under 72 characters. Body explains reasoning.

(pause)

And here's where the concrete instructions really shine. The skill refuses to commit files that look like secrets — .env files, credentials, API keys. If a pre-commit hook fails, it doesn't amend the previous commit. It fixes the issue and creates a new commit. These aren't suggestions — they're hard rules baked into the SKILL.md.

(pause)

All of that behavior — the analysis, the staging discipline, the safety checks — it's just a markdown file with clear instructions. No plugin. No SDK. Just a SKILL.md telling the agent exactly what to do and what not to do.

Here it is in action.

(play the GIF / let it loop)

Watch how the agent analyzes the diff, picks the right commit type, stages only the relevant files, and writes a clean conventional commit message.

(pause — let the audience absorb)

All from a single SKILL.md file. No plugin. No API integration. Just clear, concrete instructions in markdown.

Let me share the design principles behind Chalk Skills — because these apply to any skill you'll ever write.

First: Style transfer fidelity. When your agent writes code, it should match the existing codebase perfectly — visually and structurally. If your project uses 2-space indentation and named exports, the skill should enforce that. The agent's output should look like a human on your team wrote it.

Second: Concrete over abstract. This is the most common mistake I see. Don't write "save the file to the components folder." Write "save the file to src/components/Name/index.tsx." Don't write "use the brand color." Write "use #00FF00." Real paths. Real values.

Third: Human in the loop. This is critical. Agents generate documentation and code via skills, but humans review and approve it. Generation creates options. Approval creates truth. Agents should never silently merge generated content into your project's source of truth.

If you remember one thing from this talk, let it be this: concrete instructions and human approval. That's how you build skills that actually work.

You don't have to start from scratch. There's already a massive ecosystem at skills.sh with thousands of community-built skills — frontend, testing, DevOps, documentation, and more.

Install them with a single command: npx skills add owner/repo. Start specializing your agents today.

And if you build something cool — contribute it back. The ecosystem grows when developers share their expertise as skills.

That's the talk! Let's open the floor.

Before we do — I want to leave you with one challenge: What workflow will you turn into a SKILL.md file this weekend?

Think about it. That one task you keep explaining to your agent over and over. That's your first skill.

Who's got a question?

Thank you everyone! I'm David Panonce, Co-founder and CTO at FrontierAI Works.

Scan the QR code to connect with me on LinkedIn. You can also find me on X at @Breadoncee and on GitHub at breadoncee.

If you want to discuss how skills can work for your team, or if you're interested in what we're building at FrontierAI — reach out. I'd love to chat.

Thank you!