Mahmoud Halat
All notes

May 5, 2026 · 5-min read

Skills are the new package manager (and they work in Lovable too)

How the same Claude Code skill folder works across Lovable, Cursor, Codex, and a half-dozen other agents reading AGENTS.md at a repo root. The mental model is npm packages, for prompts.

agentsskillslovableclaude-code

A few weeks ago I was building a landing page for a client in Lovable and caught myself typing out the same anti-AI-slop rules I'd already written into a Claude Code skill the week before. I stopped, mirrored the skill repo to a Lovable project, dropped an AGENTS.md at the root explaining how the rules should work, and @-mentioned that project from the client's site. The agent read the rules and applied them. Same skill, two completely different agents, one folder of markdown sitting in a GitHub repo.

That's been the actual lift this year. Not the skills themselves, which are just markdown in folders, but the fact that the same folder works across Claude Code, Lovable, and the half-dozen other coding agents that read AGENTS.md at a repo root. Worth walking through how it actually works, since the docs across the four or five different vendors involved don't quite tell the whole story when you read them separately.

What a skill actually is#

A skill is a folder containing a SKILL.md file, which itself has YAML frontmatter (name, description, when it should fire) and a markdown body of instructions. Beside the SKILL.md you can drop a references/ folder of longer reference docs the agent loads on demand, plus optional scripts/ for code the agent can execute against your project. That's the whole spec.

Claude Code follows the Agent Skills open standard, which Anthropic released as an open format and which their docs describe as portable across tools and platforms. Because a skill is just markdown, it can live anywhere you can put markdown, which means a GitHub repo, a Lovable project, an internal Notion export, even a USB stick.

In Claude Code#

Skills install to ~/.claude/skills/<skill-name>/ and the agent watches the folder. When you ask something whose request matches the skill's description, Claude pulls the SKILL.md into context and follows it, optionally loading any of the references you pointed it at. The reference files only load on demand, which means a 3,000-line knowledge base costs almost nothing in tokens until the agent actually needs one specific section. That progressive-disclosure piece is the whole reason skills work at scale, since the routing layer stays small while the references can be as heavy as you want.

In Lovable#

Lovable doesn't have a skills surface in the Claude Code sense, but Agent Mode supports cross-project @ mentions inside a workspace. The official docs put it like this:

Lovable supports cross-project referencing within the same workspace. You can use @ mentions to reference another project directly, or simply ask Lovable to reuse an existing implementation. The agent can access relevant code, files, assets, and chat history from other projects and adapt them to your current one. Cross-project access is read-only and respects workspace permissions.

The trick is to mirror the skill repo as a Lovable project, drop an AGENTS.md at the root that tells the agent how to use the rules, and then @-mention that mirror from any other project that needs them. I do this with slop-cop. The canonical skill lives at github.com/MahmoudHalat/slop-cop, the Lovable mirror lives at slopcop.lovable.app, and any client landing page I'm building can @ it and get every draft audited the same way without me copy-pasting rules into each new project.

Why I think this matters#

The format is open and increasingly cross-vendor. AGENTS.md was donated to the Linux Foundation's Agentic AI Foundation in December 2025 alongside MCP and Goose, and the agents.md homepage now lists 60k+ open-source projects using it and at least 25 tools reading it, including Codex, Cursor, Windsurf, Devin, Copilot's Coding Agent, Aider, goose, Zed, and JetBrains Junie. That's a real cross-tool standard rather than vendor lock-in, and the mental cost of switching agents later is approaching zero.

Updates also land in one place and propagate from there. I push to a single GitHub repo and the Claude Code people install with one curl command, the Lovable people @-mention the mirror, the Cursor and Codex people read the AGENTS.md at the repo root. When I find a new AI tell or want to adjust a comprehension threshold, every consumer gets it on the next conversation without me touching anything in their projects.

The structure also scales the way I want to scale, which is mostly by accident. Today I have two skills published. Adding a third, probably a Reddit-strategist next and then a customer-research playbook after that, is essentially copy-paste of the same structure, and they end up independently versioned, independently installable, and composable through whichever agent the reader happens to be running.

The mental model that finally clicked for me is that skills are starting to feel like npm packages but for prompts. Versioned, distributed, dependency-aware in the sense that one skill can call another through the agent, runnable across environments. Most of the agent space isn't there yet, but the format already exists and the tooling is mostly catching up.

What I'm building toward#

The site I'm shipping right now uses three skills in sequence behind the scenes. The SEO guide writes the brief, the writer skill drafts the post, and slop-cop does the final voice and comprehension audit before anything goes live. I never manually invoke any of them; the agent picks the right one based on what I'm asking for, and the whole pipeline runs in a few seconds.

If you're building any kind of agent-driven workflow, the cheap move right now is to package your standing instructions as a skill, push it to GitHub, and mirror it to Lovable. You can switch tools later without rewriting any rules, and each skill you write keeps earning its keep the longer it lives.

Sources#