# Combine Skills and MCP to Close the Context Gap

Pedro Rodrigues, Supabase

AI Engineer Europe 2026

[Talk page](https://ai.engineer/talks/JT3OzDKrucU-combine-skills-mcp-close-context-gap) · [Video](https://www.youtube.com/watch?v=JT3OzDKrucU)

## Combine Skills and MCP to Close the Context Gap

An agent can have the tools to change a database and still miss its security rules. Supabase’s skill shows how product guidance turns access into safer, more effective work.

Basic familiarity with SQL tables and views, database permissions, and agents that call tools will help you follow the examples.

### What does an agent need beyond access?

[0:18](https://www.youtube.com/watch?v=JT3OzDKrucU&t=18s)

What does an agent need to use a complex product correctly once it has tools to operate it? The debate over MCP versus skills obscures their complementary roles. Pedro Rodrigues, an AI tooling engineer at Supabase, approaches the question through the experience of writing a product skill—a document he says demanded more work than any single document since his master’s thesis. He also introduces himself as a Lisbon AI Week co-founder. The difficulty is not producing Markdown; it is deciding what guidance a complex product needs to give an agent.

A capable agent can complete routine work yet miss a feature introduced after training, omit a security requirement, or choose an awkward workflow. At Supabase, missing **row-level security**, or RLS, instructions can expose application data. Rodrigues also observes agents relying on stale training knowledge instead of retrieving current documentation. The missing ingredient is product-specific guidance: what must be protected, where current information lives, and how the product team expects work to proceed.

![Slide titled “Agents are smart enough. They just need the right guidance.” with three cards: Security pitfalls, Stale knowledge, and Missing workflows.](https://ai.engineer/api/talk-essay-media/7466a40cbd4ab9bb93190f70cac0f2607dc21b2c3fea0a450d0f3edfb046a754)

Agents need guidance on security pitfalls, stale knowledge, and missing workflows.

The [Agent Skills format](https://agentskills.io/specification) makes that guidance available progressively. A skill is a folder containing a main `SKILL.md` file and optional supporting resources. Its front matter supplies the `name` and `description` that help an agent decide whether to load it. The body contains instructions; bundled scripts can perform actions; reference files hold material that need not enter context immediately. This separation keeps initial context small, but it also makes later retrieval a decision the agent must actually take.

### A SQL view can reopen protected data

[3:35](https://www.youtube.com/watch?v=JT3OzDKrucU&t=215s)

Supabase tested **Claude Sonnet 4.6** with the same prompt under two conditions: access to the [Supabase MCP server](https://supabase.com/docs/guides/ai-tools/mcp) alone, and MCP plus the skill. The task was to create a SQL view over an existing table in a collaborative application. The table already had RLS enabled so users could see only information belonging to them. Creating a view should preserve that isolation.

The consequential detail was `security_invoker = true`. Under [PostgreSQL view semantics](https://www.postgresql.org/docs/15/sql-createview.html), a default view uses the view owner’s permissions and RLS policies for underlying relations. A privileged owner can therefore bypass the restrictions that apply to an ordinary caller—the risk in this demonstration. Setting `security_invoker = true` makes the underlying checks use the caller instead. This option requires PostgreSQL 15 or later; a default view does not universally bypass every RLS policy regardless of ownership.

For a collaboration table named `public.documents`, the essential SQL would look like this:

```sql
CREATE VIEW public.document_summary
WITH (security_invoker = true)
AS
SELECT id, owner_id, title
FROM public.documents;
```

The existing table policies still determine which documents a caller can read. The view option preserves the caller’s security context rather than replacing those policies. In Rodrigues’s comparison, the skill-equipped agent included the option; the MCP-only agent omitted it and exposed data through the view. **Access to a tool did not supply the knowledge needed to use it safely.**

![Slide titled “Same prompt. Different context.” compares two SQL panels, with a red data-exposure warning on the left and green proper-data-isolation confirmation on the right.](https://ai.engineer/api/talk-essay-media/2713292bfb5caeb60db417c2d777c203e4f0c96fbeb744040e3a6b219e94497f)

The same prompt produces contrasting view definitions with MCP only and MCP plus a skill.

That example motivated the broader [Supabase Agent Skill](https://github.com/supabase/agent-skills), which Rodrigues announced after several months of development and publicized with a live tweet on stage. Its instructions encode lessons about operating Supabase correctly. The file format provides a container, but the conventions for writing effective free-text guidance are still evolving.

### Keep documentation authoritative and essential checks unavoidable

[5:56](https://www.youtube.com/watch?v=JT3OzDKrucU&t=356s)

The first authoring principle is to avoid duplicating product documentation. A skill should tell the agent **where and how to find current information**, rather than becoming a second copy that can drift. Simply providing a link may not be enough: Rodrigues found that instructions needed to insist on retrieval because agents otherwise continued from their training knowledge.

Supabase’s experimental [documentation over SSH](https://supabase.com/blog/supabase-docs-over-ssh) explores another way to make retrieval familiar. It exposes documentation through a virtual filesystem that agents can navigate using familiar filesystem and Linux-style tools. The premise is that an interface resembling files and directories will be easier for agents to explore. It is a documentation interface, not an unrestricted remote shell, and easier navigation remained the experiment’s premise rather than a measured result presented here.

The second principle addresses the weakness of progressive loading: optional information can remain unread. Rodrigues observes that fetching fresh information and making tool calls impose costs, encouraging agents to fall back on training data. Even loading `SKILL.md` does not ensure that the agent reads its references. In Supabase’s experiments, getting an agent to load two necessary reference files was difficult; expecting three or four was still less dependable.

Supabase initially placed its security checklist in a reference file and found that agents frequently missed it. Moving the checklist into `SKILL.md` made it part of the main instructions. This produces a useful division of responsibility:

- **Current product details:** Retrieve them from the authoritative documentation.
- **Stable, indispensable rules:** Put them directly in `SKILL.md`.
- **Optional depth:** Keep it in references when skipping it will not undermine the task.

Avoiding duplicated documentation does not mean hiding the product’s essential security rules behind another retrieval step.

### Prescribe the schema workflow

[9:11](https://www.youtube.com/watch?v=JT3OzDKrucU&t=551s)

The third principle is to be opinionated. A product team knows which workflows fit its system and should make that knowledge explicit. Supabase supplies a database, storage, authentication, and other backend features; an agent working with it can manipulate the database schema directly. The skill therefore needs to explain how that work should proceed, not just which commands exist.

Rodrigues describes this schema-development sequence:

1. **Iterate with direct DDL** on a development or staging database until the schema is satisfactory.
2. **Run the advisors**, which act as linters for database security and performance issues.
3. **Fix the reported issues** before finalizing the change.
4. **Create the migration file** after the schema has settled.

The development-or-staging restriction matters: this is not permission to experiment freely against production. Delaying the migration file also prevents the agent from generating a new migration for every intermediate schema edit. This is the workflow presented in the talk; the current skill has since added distinctions between declarative and imperative projects.

### Test the Markdown through agent behavior

[10:59](https://www.youtube.com/watch?v=JT3OzDKrucU&t=659s)

A skill can be evaluated through the behavior it induces. Instead of testing the Markdown as text, run an agent on a task and inspect what it does: its tool calls, reasoning, and completion of the requirements. Rodrigues treats these evaluations as analogous to CI tests, with the document supplying instructions to the system under test.

The early evaluation used six scenarios involving ongoing Supabase projects, four agent/model configurations from two vendors, and three conditions:

| Condition | Tool access and guidance |
| --- | --- |
| Baseline | Neither MCP nor skills |
| MCP only | MCP server, without the skill |
| MCP plus skill | MCP server and product instructions |

Task completeness was graded in Braintrust. Rodrigues describes a four-grade score, but does not define the grading levels in the talk. The design has no skill-only condition, so it tests the benefit of adding the skill to MCP rather than isolating the skill’s performance without tools.

Rodrigues reports that MCP plus the skill achieved higher task-completeness scores than either baseline or MCP alone on every tested model. The configurations were Claude Code with **Claude Opus 4.6** and Claude Sonnet 4.6, and Codex with **GPT-5.4** and **GPT-5.4 mini**. The [launch article](https://supabase.com/blog/supabase-agent-skills) characterizes these as small-sample early results. They support the practical value of product guidance in these scenarios without establishing which particular instruction caused each improvement.

![“Skills improved agents” slide with four groups of three bars and a legend for Baseline, MCP Only, and MCP + Skill; green bars are tallest throughout.](https://ai.engineer/api/talk-essay-media/920750237152d8b4122f77cd09dd824a6d18a09056d9e4318a0a3a0db1af82b8)

MCP plus a skill has the tallest bar in each of four agent and model groups.

### Start small and revise the guidance

[12:59](https://www.youtube.com/watch?v=JT3OzDKrucU&t=779s)

Supabase already had the MCP tools. What it needed was guidance on how to operate the product. Skills provide an agent-agnostic format with growing adoption, making the instructions reusable across supporting agents. The authoring approach follows from that: point to one documentation source of truth, prescribe the workflows that matter, and begin with a minimal skill that can expand through testing and new versions. **The bottleneck here is guidance, not merely access to more context.**

Rodrigues closes the main presentation by pointing to the launch post and project installation. The companion article gives the installation command:

```bash
npx skills add supabase/agent-skills
```

The release makes the skill available to try in a project and iterate on as its instructions evolve. Before audience questions, Rodrigues also announces a launch giveaway: scanning the displayed QR code and signing up for Supabase offered a chance to win a Mac mini.

### Semantic retrieval and repository distribution

[14:55](https://www.youtube.com/watch?v=JT3OzDKrucU&t=895s)

An audience question about vector databases and RAG extends the retrieval discussion. Rodrigues reports increasing customer exploration of vectors, without giving customer counts. His particular interest is embeddings for semantic search: documentation exposed through SSH could be searched by meaning, rather than only through filesystem navigation and text matching. The proposed extension is to augment familiar Bash-style tools with semantic retrieval. It is a possibility for the SSH interface, not a capability demonstrated in this talk.

The next question is operational: how should an organization distribute its skills—directly, through repositories, or with a package manager? Rodrigues describes distribution as an unsettled part of the ecosystem. The [Vercel skills CLI](https://github.com/vercel-labs/skills) offers one route; plugins offer another, bundling skills with MCP servers and other components, but with packaging tied to particular agent environments.

Supabase’s internal approach is to package skills in the repositories themselves. Rodrigues gives `.claude` and `.cursor` plugin packaging as examples of making repository knowledge discoverable to an agent. The skills package can then fetch skills from public repositories or repositories the user can access. He sees other companies following the same pattern: keep the skill with the project knowledge it describes, then distribute it through the available installation mechanism. That gives teams a concrete way to ship guidance while the broader registry and plugin ecosystem continues to develop.

## Resources

- [Supabase Agent Skills launch and evaluation](https://supabase.com/blog/supabase-agent-skills) — Rodrigues explains the skill's design and publishes the early four-model evaluation.
- [Supabase Agent Skills](https://github.com/supabase/agent-skills) — Installable Supabase skills with instructions for repository and plugin distribution.
- [PostgreSQL view security semantics](https://www.postgresql.org/docs/15/sql-createview.html) — Explains view ownership, permissions, RLS policies, and security_invoker.
- [Supabase row-level security](https://supabase.com/docs/guides/database/postgres/row-level-security) — Practical guidance for policies, grants, testing, and safely exposing views.
- [Supabase docs over SSH](https://supabase.com/blog/supabase-docs-over-ssh) — The experimental documentation interface exposes markdown through familiar filesystem commands.
- [Agent Skills specification](https://agentskills.io/specification) — Defines skill folders, metadata, instructions, optional resources, and progressive loading.
- [Vercel skills CLI](https://github.com/vercel-labs/skills) — A command-line tool for discovering and installing skills across coding agents.
- [Supabase MCP setup](https://supabase.com/docs/guides/ai-tools/mcp) — Current connection instructions and security guidance for Supabase's MCP server.
- [Supabase's later public evaluation framework](https://supabase.com/blog/introducing-supabase-evals) — The July 2026 release expands evaluation into a public benchmark and regression framework.

## Slides

### Skill Issue

Pedro shares lessons from writing the Supabase skill, a document he says became complex because Supabase itself is a complex product.

[0:45](https://www.youtube.com/watch?v=JT3OzDKrucU&t=45s) [Title slide: Skill Issue, what was learned from writing the Supabase skill.](https://assets.ai.engineer/sites/aiecode2025/sha256/9962f6f12a95b3951ba645149bd6709488cd3e377c06d326573e6da3ae997bcd.webp)

Skill Issue
What we learned from writing the Supabase skill

Lessons on teaching AI agents to know your product

AI Engineer Europe 2026 · London · Pedro Rodrigues · Supabase

Interface text:
supabase  1/16
← → navigate

AIE
AI Engineer EUROPE
AI Engineer EUROPE 2026

### Hi, I'm Pedro

Pedro Rodrigues introduces himself as an AI tooling engineer at Supabase and co-founder of Lisbon AI Week. He co-hosted MCP Conference Lisbon 2025.

[1:08](https://www.youtube.com/watch?v=JT3OzDKrucU&t=68s) [Pedro introduces himself as an AI tooling engineer at Supabase and co-founder of Lisbon AI Week.](https://assets.ai.engineer/sites/aiecode2025/sha256/d538b5940d4a301b6ac07a178985245411b6a5ad007034088f7ae1d0737f5d03.webp)

Hi, I'm Pedro
Full time Software Engineer, Part time Sports Lover

Connect on LinkedIn

AI Tooling Engineer @ Supabase
MCP Enthusiast

Co-founder of Lisbon AI Week
Co-hosted MCP Conference Lisbon 2025

LinkedIn: pedro-neves-rodrigues
X: @Rodriguespn23
GitHub: Rodriguespn

Interface text:
supabase  2/16
← → navigate
AIE
AI Engineer EUROPE
2026

### Agents need the right guidance

At Supabase, agents can miss security requirements, rely on outdated APIs, or lack guidance for schema and migration workflows. Product-specific guidance can help fill those gaps.

[1:45](https://www.youtube.com/watch?v=JT3OzDKrucU&t=105s) [Slide lists security pitfalls, stale knowledge, and missing workflows as areas where agents need guidance.](https://assets.ai.engineer/sites/aiecode2025/sha256/004df21f89696f552f57d242e25694f4350be5014d8e0851d275e6b6c813bb96.webp)

Agents are smart enough. They just need the right guidance.

Here's what we see on our platform. If you build a product, you've seen your version of this.

Security pitfalls
RLS bypasses, key exposure, policy gaps

Stale knowledge
Outdated APIs, deprecated patterns

Missing workflows
Schema management, migration best practices

Interface text:
supabase 3/16
← → navigate

Event text:
AIE
AI Engineer EUROPE 2026
Engineering the future of AI

### Same prompt, different context

In Supabase’s test, the MCP-only agent created a view that exposed all teams’ data. With a skill, it added security_invoker = true, preserving row-level security.

[3:35](https://www.youtube.com/watch?v=JT3OzDKrucU&t=215s) [Slide compares an MCP-only SQL view that exposes team data with an MCP-plus-skill view that uses security invoker and preserves data isolation.](https://assets.ai.engineer/sites/aiecode2025/sha256/6205145e5cce07378413872f062765f91a05e8ab405cf9b3aba418d71c86a021.webp)

Same prompt. Different context.

“Create a team_task_summary view so team members can see how their team is doing.”

MCP only
CREATE VIEW team_summary_view AS SELECT ...
All teams' data exposed

MCP + Skill
CREATE VIEW team_summary_view WITH
(security_invoker = true) AS SELECT ...
Proper data isolation

Interface text:
supabase 5/16
← → navigate
AIE
AI Engineer EUROPE
2026

### Live announcement

Pedro Rodrigues posts the Supabase Agent Skills announcement live on stage. The post describes open-source instructions for building on Supabase and includes an installation command.

[5:25](https://www.youtube.com/watch?v=JT3OzDKrucU&t=325s) [A browser displays a social media post announcing Supabase Agent Skills over the presentation.](https://assets.ai.engineer/sites/aiecode2025/sha256/77c480228b9232657f3b65d1e72214a6b1b2611015acb94e275e7f9e0304713a.webp)

Pedro Rodrigues 🇵🇹 @rodriguespn23 · 1s

AI agents know about Supabase. They just don't always use it right.

Today, we're releasing Supabase Agent Skills — open-source instructions that teach your AI agent how to build on Supabase correctly.

`$ npx skills add supabase/agent-skills --skill supabase`

We share the...
Show more

supabase
Build in a weekend
Scale to millions
Blog Post Not Found

Your post was sent. You have 1 hour to make any edits. View

Partially obscured slide:
[illegible]gent Skills
[illegible] AI coding agents how to build on
[illegible]rrectly.
[illegible]t-skills --skill supabase
Open
STANDARD
[illegible] a principle you can apply to your own
[illegible]kill.

AIE
AI Engineer EUROPE
2026

Interface text:
aie-skill-announcement-presentation.vercel.app
x.com/home
Home
Explore
Notifications
Chat
Grok
Premium
Bookmarks
Creator Studio
Profile
More
Post
For you
Following
Build with SingleStore
LXAI
What's happening?
Search
Upgrade to Premium+
Enjoy additional benefits, zero ads and the largest reply prioritization.
Today's News
Discussions on X about "vibe coding" using AI tools like Claude for software ...
Cursor AI Adds Remote Phone Control for Code Editors
Zustand Surpasses Redux in Popularity by Weekly Downloads
What's happening
Barca

### Describe intent, not means

Point agents to up-to-date documentation instead of duplicating it: use MCP search first, fetch Markdown from a URL, and fall back to web search when MCP is unavailable.

[6:00](https://www.youtube.com/watch?v=JT3OzDKrucU&t=360s) [A slide recommends directing agents to current documentation using MCP search, Markdown URLs, or web search.](https://assets.ai.engineer/sites/aiecode2025/sha256/9be8849b303297da9f0b6ea78f840d2311e2a0ad2d50e222657932e91754d1ce.webp)

PRINCIPLE 1

Describe intent, not means

Don't tell agents what the answer is — tell them where to look and what to achieve.

1 search_docs
MCP search_docs
First choice — structured search against current docs

2 .md
Append .md to URL
Fetch raw markdown — same source as supabase.com/docs

3 web
Native web search
Fallback when MCP isn’t available

Interface text:
supabase 7/16
← → navigate
AIE
AI Engineer EUROPE 2026
Engineering the future of AI

### Supabase Docs over SSH

Supabase is experimenting with an SSH interface that lets agents navigate documentation like a remote filesystem using familiar shell tools. A second command appends its agents output to AGENTS.md.

[6:35](https://www.youtube.com/watch?v=JT3OzDKrucU&t=395s) [A slide presents an experimental SSH interface for querying Supabase documentation, with example commands and a blog preview.](https://assets.ai.engineer/sites/aiecode2025/sha256/c6a83ac696cfedced1b7f6376113a305b9817651a82bd5cde6c839fc91a61b25.webp)

EXPERIMENTAL

Supabase Docs over SSH

A more intuitive way for agents to query docs — the same bash interface they use in your local system. grep, ls, cat — against our full documentation.

$ ssh supabase.sh
$ ssh supabase.sh agents >> AGENTS.md

We’d love your feedback on this after the talk.

Interface text:
Supabase docs over SSH
01 Apr 2026 · 3 minute read
Greg Richardson
Engineering
Product · Developers · Solutions · Pricing · Docs · Blog
On this page
Setting up your [illegible]
How it’s built
Why bash [illegible]
Get started
Share this artic[illegible]
supabase · 8/16
navigate
AIE
AI Engineer EUROPE 2026
Engineering the future of AI

### Try Supabase, Win a Mac Mini

Scan the QR code for the talk deck and notes, or sign up for Supabase and enter data for a chance to win a Mac Mini.

[14:31](https://www.youtube.com/watch?v=JT3OzDKrucU&t=871s) [A giveaway slide with a QR code, instructions for accessing the talk slides and entering, and presenter contact information.](https://assets.ai.engineer/sites/aiecode2025/sha256/f2a5c8032b4a46b643f3417e94e72e53098da6a03eb23657cc437ae9964b8442.webp)

Try Supabase, Win a Mac Mini

1 Slides from this talk
Get the deck and notes.

2 Enter to win
Signup for Supabase, enter data.

3 Contact me
[redacted]

supabase.link/ai-engineer-eu-2026

Interface text:
supabase 16/16
← → navigate
AIE
AI Engineer EUROPE
AI Engineer EUROPE 2026

[14:41](https://www.youtube.com/watch?v=JT3OzDKrucU&t=881s) [Giveaway slide with a QR code, instructions for accessing the talk materials and entering, and presenter contact details.](https://assets.ai.engineer/sites/aiecode2025/sha256/683ec2f3c39ac7294d03b60f8d962d82d7fadcef2454ab99ee1ea6449b213cb7.webp)

Try Supabase, Win a Mac Mini

1 Slides from this talk
Get the deck and notes.

2 Enter to win
Signup for Supabase, enter data.

3 Contact me
[redacted]

supabase.link/ai-engineer-eu-2026

Interface text:
supabase 16/16
← → navigate
AIE
AI Engineer EUROPE 2026

## Full transcript

[0:00](https://www.youtube.com/watch?v=JT3OzDKrucU&t=0s) [upbeat music] All right, I get, I have, uh, the green light, so we can get it started.

[0:18](https://www.youtube.com/watch?v=JT3OzDKrucU&t=18s) Uh, hello, everyone. Uh, you might have noticed that the, the title's, uh, changed a bit from the one that we have in, on the schedule. That's because when I've submitted the talk, uh, there's the MCP versus skill debate was still going on, was a hot topic.

[0:32](https://www.youtube.com/watch?v=JT3OzDKrucU&t=32s) I think now we settled on they're b- both different. They all, uh, have their own roles, and now the, I think the debate is more on the MCP versus CLI.

[0:40](https://www.youtube.com/watch?v=JT3OzDKrucU&t=40s) So I thought it would be more useful to come and explain how we've wrote our Supabase skill, uh, and the lessons that we got from writing, uh, the, this document, 'cause I've never spent more time writing a single document since I've wrote my master thesis.

[0:57](https://www.youtube.com/watch?v=JT3OzDKrucU&t=57s) Okay? So I know that writing a skill sounds simple, but it can be very complex, especially when you have a complex product like Supabase. Um, for starters,

[1:09](https://www.youtube.com/watch?v=JT3OzDKrucU&t=69s) I'm Pedro. I'm, uh, an AI tooling engineer, uh, at Supabase. I'm an MCP enthusiast, AI in general. Uh, feel free to connect me on LinkedIn. Uh, and I'm al- also a co-founder of the Lisbon AI Week in, in Lisbon, will be on, uh, late October this year.

[1:26](https://www.youtube.com/watch?v=JT3OzDKrucU&t=86s) And if we're talking about me at the moment, I usually prefer, uh, doing this on a dark, darker, um, darker mode. I don't know. How many of you prefer dark mode over light mode?

[1:39](https://www.youtube.com/watch?v=JT3OzDKrucU&t=99s) The majority. I thought so. So let's do this presentation on dark mode instead. [laughing]

[1:45](https://www.youtube.com/watch?v=JT3OzDKrucU&t=105s) So we, I think we can all agree that agents are already smart enough, right? They can b- do very cap... They are very capable of doing mundane tasks by themselves.

[1:56](https://www.youtube.com/watch?v=JT3OzDKrucU&t=116s) But, uh, spe- when you present a task about something that they've haven't seen yet, or you've updated since they were trained, like your product, for example, they need the right guidance.

[2:08](https://www.youtube.com/watch?v=JT3OzDKrucU&t=128s) Uh, for ex- for example, uh, at Supabase, we noticed that they would usually either miss some, some security pitfalls that we have, uh, like row-level security instructions that, uh, they have to set, uh, to, to basically not expose your app.

[2:22](https://www.youtube.com/watch?v=JT3OzDKrucU&t=142s) Um, they could just usually operate on stale knowledge, uh, on their training data, and they are very lazy to, and very stubborn to admit that they don't know, uh, and they do need to find fresh information.

[2:35](https://www.youtube.com/watch?v=JT3OzDKrucU&t=155s) Um, and also, we would like to guide them on specific workflows that we think are the most optimized for agents, uh, on our product. So for starters, how many of you know or have written a skill before?

[2:51](https://www.youtube.com/watch?v=JT3OzDKrucU&t=171s) Okay, so what I'm going to say is pr- probably not new for the most of you, but just to get an introduction on skills. So skills, um, are folders containing instructions, scripts, and resources that agents discover, right?

[3:04](https://www.youtube.com/watch?v=JT3OzDKrucU&t=184s) Um, progressively they discover. This is the main selling point of skills. Uh, and they, they have this envelope called front matter, where they have the name and the description.

[3:13](https://www.youtube.com/watch?v=JT3OzDKrucU&t=193s) This is how the agent is going to decide when to load the skill. Then they have the actual instructions inside the file, the main file called SKILL.md, and then optional bundled resources like scripts to perform actions, um, or reference files that the main file can reference for more information that doesn't have to be loaded immediately to context.

[3:35](https://www.youtube.com/watch?v=JT3OzDKrucU&t=215s) Uh, so we tested out, uh, at Supabase. We experienced giving the same agent, uh, in this case was Claude Sonnet, uh, 4.6, uh, the same prompt for a simple task.

[3:48](https://www.youtube.com/watch?v=JT3OzDKrucU&t=228s) Like, we had an app, like a collaboration, a collaborative app, and we wanted to create this new SQL view, right, on top of a table that already had row-level security enabled.

[3:58](https://www.youtube.com/watch?v=JT3OzDKrucU&t=238s) So the users could only see the information that belonged to them. Um, we gave, uh, we gave them, uh, just the, the MCP, uh, o- on one, uh, condition, and the MCP plus the, the agents, uh, the agent skills.

[4:14](https://www.youtube.com/watch?v=JT3OzDKrucU&t=254s) And the result was, well, the expected. Uh, if you don't know in Postgres, if you create a s- a view over, uh, a table, uh, on top of a table that has RLS enabled, if you don't explicitly pass that, um, that flag over there, the security_invoker = true, it will bypass the RLS.

[4:33](https://www.youtube.com/watch?v=JT3OzDKrucU&t=273s) So basically, the view will expose data that is not dis- exposed by default on the, uh, uh, on the table. So the agent with the skill, with the knowledge, was able to get this, uh, uh, th- this information implemented correctly and safely, while the one that only had access to the integration to the, to the m- to

[4:53](https://www.youtube.com/watch?v=JT3OzDKrucU&t=293s) the MCP tool did not. So for this, we decided, well, just like this, we wanted to, uh, enable agents to know how to work correctly with, uh, with Supabase.

[5:07](https://www.youtube.com/watch?v=JT3OzDKrucU&t=307s) So we decided to, we are announce- actually announcing today, uh, this, um, this Supabase Agent Skill that I've been working on on this couple, uh, couple past few months. And to make things official, I'm actually going to try something.

[5:22](https://www.youtube.com/watch?v=JT3OzDKrucU&t=322s) Wait. I'm going to live tweet it on stage. So it's live. [clapping]

[5:37](https://www.youtube.com/watch?v=JT3OzDKrucU&t=337s) All right. So, uh, what exactly is this skill about, and what lessons can I share with you? So if you're building a skill for your product, uh, you can build one like we did.

[5:47](https://www.youtube.com/watch?v=JT3OzDKrucU&t=347s) And happy to discuss the, all details, like this is free text- text, and we haven't achieved a, a standard for it. So happy to, to chat about it later.

[5:56](https://www.youtube.com/watch?v=JT3OzDKrucU&t=356s) Uh, so to break down on some principles that we, um, converge to, the first one is that- Don't duplicate information. Yeah, like treat s- uh, skills as a document, uh, documentation for yourself, and you will not do- uh, um, duplicate your documentation, right?

[6:12](https://www.youtube.com/watch?v=JT3OzDKrucU&t=372s) You already have documentation on your product. Just point the agent to it, to the most up-to-date. You'll have to be very stubborn with the model to go to ask them to go f- uh, s- search the, the web or your documentation.

[6:26](https://www.youtube.com/watch?v=JT3OzDKrucU&t=386s) Provide the guidance, the tell where to and how to find the documentation, but be very persistent with it, uh, to go for it.

[6:36](https://www.youtube.com/watch?v=JT3OzDKrucU&t=396s) We're also, uh, did, uh, run a little experiments, and this is, uh, still, um, well, as I said, uh, an experiment and yet to be, um, uh, bit, uh, um, we're still figuring out the details.

[6:50](https://www.youtube.com/watch?v=JT3OzDKrucU&t=410s) But we also announced quite recently, and you can see it, you can read it on our blog, we're expo- we're basically exposing our documentation through, uh, SSH. The main reason behind it is that the agents can now look for the documentation like it was a file system.

[7:06](https://www.youtube.com/watch?v=JT3OzDKrucU&t=426s) So they're very familiar with file systems in general or navigating them, finding files and information on, uh, using Linux-based, um, tools. If we expose, if we give them this interface to also do this but remotely, uh, w- our premise is that they will have easy, um, ease to, to navigate the, the documentation.

[7:26](https://www.youtube.com/watch?v=JT3OzDKrucU&t=446s) So would also would love a- after the talk or during the, uh, the conference to see and to hear your opinions on, on this idea. The second principle that I got, that I ge- I have for you is that if something can get skipped, it will be skipped.

[7:44](https://www.youtube.com/watch?v=JT3OzDKrucU&t=464s) What I mean by this is that besides, uh, new information on, uh, searching online, so agents, uh, like fetching information online or tool calling, it's expensive for, for agents, so they mostly defa- uh, default to their training data.

[7:59](https://www.youtube.com/watch?v=JT3OzDKrucU&t=479s) The same is true for reference files. We've noticed that, uh, even if, uh, when the, the agent loaded the skill, uh, it will, uh, even if it had reference files there, uh, it will be very lazy to load them.

[8:14](https://www.youtube.com/watch?v=JT3OzDKrucU&t=494s) And even if it loads one reference file, uh, if your problem requires more than one, the information that it's more the, uh, in more than one file, uh, it will most likely will not load two files, right?

[8:26](https://www.youtube.com/watch?v=JT3OzDKrucU&t=506s) It's almost impossible and not, not even starting on three or four. Um, so you have to be, um, very critical about what you put on your SKILL.md file from the beginning.

[8:38](https://www.youtube.com/watch?v=JT3OzDKrucU&t=518s) You put information that it's likely not to change, like in our case, a security checklist about Supabase, um, that we didn't really want it the agent to miss at all.

[8:49](https://www.youtube.com/watch?v=JT3OzDKrucU&t=529s) Uh, so we decided this cannot be on a reference file. We actually started by putting it on a reference file, and it usually missed it, so we put it on the skill itself.

[8:57](https://www.youtube.com/watch?v=JT3OzDKrucU&t=537s) So if you have any, um, information that the agent can just not miss and, like, defines your product, goes to the SKILL.md file. Do not afford it to put on, on a reference file.

[9:11](https://www.youtube.com/watch?v=JT3OzDKrucU&t=551s) And lastly, uh, the third principle that I have for you when writing a product skill is to be opinionated. You know your product the best. You know how to work with it.

[9:21](https://www.youtube.com/watch?v=JT3OzDKrucU&t=561s) You know how your users, or you should know how your users are using it. Um, don't be afraid of guiding the agents on what, on workflows, uh, that you think are the most effective when working with your product.

[9:35](https://www.youtube.com/watch?v=JT3OzDKrucU&t=575s) In our case, for example, uh, managing a database schema, right? I haven't, I actually haven't, uh, asked this and should have i- in the, the beginning. How many of you know Supabase and what Supabase does?

[9:46](https://www.youtube.com/watch?v=JT3OzDKrucU&t=586s) Okay. For, so for the ones who, who don't know, we're basically a back-end service. We provide, uh, a storage b- database, authentication, and other f- uh, features that you would need to create a, uh, back end, uh, out of the box.

[10:00](https://www.youtube.com/watch?v=JT3OzDKrucU&t=600s) So we provi- or as I said, I pro- we provide a database, and the agent can interact and manipulate your, your schema, right? Uh, we found that this, uh, for our platform was the best workflow for the agents to efficiently, uh, manage the schema.

[10:16](https://www.youtube.com/watch?v=JT3OzDKrucU&t=616s) So in this case, it run, uh, direct DDL operations, like change the schema freely on your d- um, development or staging database. Once you're happy about it, we provide, uh, an advisor who are basically linters, uh, to give any, uh, security or performance issues that the database cou- could have, fix them, um, and only then create the

[10:40](https://www.youtube.com/watch?v=JT3OzDKrucU&t=640s) migration file. So this will prevent the agent to create a migration file every time it changes the schema. We found this li- to be the best, um, workflow to manage the schema, so for us, it should be in the, um, in the skill when working with, with, with Supabase.

[10:59](https://www.youtube.com/watch?v=JT3OzDKrucU&t=659s) How we tested this skill? So we're living, uh, a very interesting times where we now can test free text. We, we can now test, um, documents. We can now test documentation, right?

[11:10](https://www.youtube.com/watch?v=JT3OzDKrucU&t=670s) Uh, this would be, uh, completely bonkers to think, uh, years ago. Now I've basically been testing a markdown file. And how did we do this? Uh, through evals. Uh, so for those of you who don't know evals, evaluations for, short for evaluations, are basically, uh, tests that you can run m- mostly like you would run, uh, on

[11:31](https://www.youtube.com/watch?v=JT3OzDKrucU&t=691s) your CI. Uh, but the, uh, now instead of evaluating code, you're evaluating an agent, an LLM, and its behavior, what tools it's co- it's calling, wha- what's the, its reasoning, right?

[11:41](https://www.youtube.com/watch?v=JT3OzDKrucU&t=701s) And so we ran, on an early stage, we ran, uh, a set of six sp- specific scenarios for Supabase, so Sup- ongoing Supabase projects in different, uh, situ- uh, in different scenarios, right?

[11:54](https://www.youtube.com/watch?v=JT3OzDKrucU&t=714s) And we ran it against four different, uh, agents, uh, from two vendors, um, in three test conditions. So we wanted to test on a baseline, so no MCP, no skills, with just the MCP server and with the MCP server plus the skill.

[12:09](https://www.youtube.com/watch?v=JT3OzDKrucU&t=729s) All this was done based on a task completeness score, uh, four graded score, uh, that run on Braintrust. If you don't know them, they're around. They're sponsors of this, uh, conference.

[12:21](https://www.youtube.com/watch?v=JT3OzDKrucU&t=741s) Go, um, go to their booth and, and talk about it. It's a very cool product. So the results are, uh, are out here. Um- The skills plus the MCP, uh, outperform any other conditions on every model that we, we tested.

[12:36](https://www.youtube.com/watch?v=JT3OzDKrucU&t=756s) So we tested on, on Claude Code for Opus 4.6 and Sonnet 4.6, and also on Codex for GPT-5.4 and GPT-5.4 mini. Uh, so I think we can conclude that it's pretty na- unanimous that the skills were actually improving the performance, the task completeness score, uh, because they were providing the right guidance to, to the agent.

[12:59](https://www.youtube.com/watch?v=JT3OzDKrucU&t=779s) So we had already the tools. We already had an MCP server. We just needed the right guidance on how to operate with, with Supabase. Uh, it's agent a- agnostic.

[13:09](https://www.youtube.com/watch?v=JT3OzDKrucU&t=789s) Uh, most, uh, more and more agents are adopting this, uh, open standard, uh, on, on skills. Um, and currently, as I said, uh, in the beginning, the bottleneck is not the, uh, the context.

[13:22](https://www.youtube.com/watch?v=JT3OzDKrucU&t=802s) It's the guidance. So if you can take something from this talk, uh, when building a skill for your product, is that point for your single source of truth. Point to your documentation, basically.

[13:36](https://www.youtube.com/watch?v=JT3OzDKrucU&t=816s) Be opinionated. You know your product. Don't be afraid to, to show it. And start minimal. Any model vendor, let's say whether that's Anthropic, OpenAI, on any blog post about skills, you will read start s- uh, start minimal, start slow, and then iterate, expand.

[13:55](https://www.youtube.com/watch?v=JT3OzDKrucU&t=835s) Don't be afraid to create new versions for it.

[14:00](https://www.youtube.com/watch?v=JT3OzDKrucU&t=840s) So if you want to know more about it, we, uh, we actually wrote a, a blog post. Uh, it's live today. You can check it out on my Twitter account, on, on Supabase, um, blog.

[14:12](https://www.youtube.com/watch?v=JT3OzDKrucU&t=852s) Uh, or you can just run this, uh, this command and install your, um, install it on your project and start to s- to, to use them now. That's all.

[14:23](https://www.youtube.com/watch?v=JT3OzDKrucU&t=863s) I'll be around. And once again, thank you very much. [audience applauding]

[14:32](https://www.youtube.com/watch?v=JT3OzDKrucU&t=872s) I do have one more thing to show you. So we're running a g- a, a giveaway. If you want to, to have a chance to win a Mac mini, uh, just scan the, the QR code,

[14:44](https://www.youtube.com/watch?v=JT3OzDKrucU&t=884s) uh, sign up for Supabase, and good luck.

[14:49](https://www.youtube.com/watch?v=JT3OzDKrucU&t=889s) Do I have time for any questions, if there's any?

[14:53](https://www.youtube.com/watch?v=JT3OzDKrucU&t=893s) Yeah.

[14:54](https://www.youtube.com/watch?v=JT3OzDKrucU&t=894s) Yeah? Okay. Yeah.

[14:55](https://www.youtube.com/watch?v=JT3OzDKrucU&t=895s) Uh, I actually have one. Uh, so since we're all moving into RAGs right now, uh, I'm just wondering how much of a demand do you guys see on vectorized databases, uh, on Supabase, right?

[15:08](https://www.youtube.com/watch?v=JT3OzDKrucU&t=908s) Hmm. It's a, it's an interesting, interesting question. So, uh, I mean, it depends. The, the... You, you, you're asking about, like, uh, how many customers are-

[15:19](https://www.youtube.com/watch?v=JT3OzDKrucU&t=919s) How much are you, um, having demand for vectorized databases?

[15:22](https://www.youtube.com/watch?v=JT3OzDKrucU&t=922s) There have been more and more, uh, as the, as the days passed. Like, um,

[15:28](https://www.youtube.com/watch?v=JT3OzDKrucU&t=928s) the use cases for, for vectors are mainly for embeddings, right?

[15:31](https://www.youtube.com/watch?v=JT3OzDKrucU&t=931s) Yeah.

[15:31](https://www.youtube.com/watch?v=JT3OzDKrucU&t=931s) Yeah. And semantic, uh, uh, uh, there are many use cases for, for embeddings. The one that I'm most interested about is, uh, um, semantic search, right? That you could use to provide even more context, uh, for example, through the SSH, uh, exposing, uh, the docs through the SSH.

[15:49](https://www.youtube.com/watch?v=JT3OzDKrucU&t=949s) You can now, instead of naively, uh, let them navigate with the, the bash tools, you can augment the tools, the already known bash tools, into providing some sort of, uh, semantic search.

[16:02](https://www.youtube.com/watch?v=JT3OzDKrucU&t=962s) So I do see a very big potential on vectors. On our data, definitely customers have been exploring more this, uh, this solution. Thank you for the question.

[16:14](https://www.youtube.com/watch?v=JT3OzDKrucU&t=974s) Thanks.

[16:16](https://www.youtube.com/watch?v=JT3OzDKrucU&t=976s) Yeah.

[16:17](https://www.youtube.com/watch?v=JT3OzDKrucU&t=977s) So thank you for the talk. Very interesting. How do you distribute the skills inside your organization? Do you,

[16:25](https://www.youtube.com/watch?v=JT3OzDKrucU&t=985s) do you just pass them? Do you have a repository? You have repository or do you use some package manager?

[16:31](https://www.youtube.com/watch?v=JT3OzDKrucU&t=991s) That's, that's an amazing, that's amazing question because, uh, currently one of the downsides or the, I would say the, the constraints of using skills is their distributions, uh, distribution system, right?

[16:43](https://www.youtube.com/watch?v=JT3OzDKrucU&t=1003s) Uh, we're still finding the- there's still some players trying to reclaim, uh, the either the registry or the way to distribute it. So Vercel came up with the skills package.

[16:53](https://www.youtube.com/watch?v=JT3OzDKrucU&t=1013s) Uh, we're seeing plug-ins, right, that you can bundle with MCP servers and other things. Uh, but they are model specific. So this is to distribute in general, skills in general.

[17:04](https://www.youtube.com/watch?v=JT3OzDKrucU&t=1024s) It's already a pro- a problem for, for itself that we haven't solved it yet. Um, internally, we have, uh, we are packaging the skills on the, the repos them- themselves.

[17:14](https://www.youtube.com/watch?v=JT3OzDKrucU&t=1034s) So if you want to, uh, create a plug-in, you just, uh, create a .claude, uh, plug-in or a .cursor plug-in or whatever in that repo, right? Uh, and then it's available, or, or it's discoverable, uh, if the, if the, the repo it's, it's, it's open sourced or, or you have access to it, uh, you can use the

[17:35](https://www.youtube.com/watch?v=JT3OzDKrucU&t=1055s) skills package to, to fetch it. So yeah, this... And this is how I've seen the other, uh, companies, uh, uh, distributing their skills. Like a repo, a skill. Trying to package the, the skills into the, the knowledge.

[17:49](https://www.youtube.com/watch?v=JT3OzDKrucU&t=1069s) Thank you.

[17:50](https://www.youtube.com/watch?v=JT3OzDKrucU&t=1070s) Thank you. Are there any more? I think we have time for one more. Yeah. Yes.

[17:58](https://www.youtube.com/watch?v=JT3OzDKrucU&t=1078s) I recently built something to build skills. Should we do a collab?

[18:02](https://www.youtube.com/watch?v=JT3OzDKrucU&t=1082s) Sure. Let, let's talk after. All right. So once again, thank you very much. It was a pleasure to be here. I'll be around. Thank you. [audience applauding] [upbeat music]
