made with Gemini AI

Your Coda Standards, AI-Ready

How Skill Files give AI agents the context to build like you

I have been building in Coda long enough to have strong opinions about how things should be done. Some of those opinions I have written about on this blog. Others live in recurring decisions I make without thinking.

That last part is what pushed me toward Skill Files. In the previous post I made the case that Skills replace templates — not because templates are technically broken, but because they solve the wrong problem. What makers actually need isn’t a pre-built structure to copy. It’s the reasoning behind the structure.

**The Coda Curious** is the brand we built around this question. How do you give an AI agent the context it needs to work the way you work?

What is a Skill File?

A Skill File is a structured Markdown document that tells an AI agent — concretely, in plain language — how to think and behave inside a specific environment. By providing a defined title and description, you help your AI stay on track and perform more effectively.

In practice, that means things like:

• Table names follow a DB prefix convention. Why? Because it visually separates base tables from cross-docs and views at a glance.
• Display columns are always called Name. Every table. No exceptions.
• ForEach() is used instead of FormulaMap(). Not because one is wrong, but because consistency across a workspace matters when you are reading someone else's formula at 11pm.
• WithName() is preferred over Let(). Same reason — one is more readable in how Coda renders expressions.

These are not rules invented for their own sake. They are the distilled output of building real documents for real clients over a long time. A Skill File captures that experience in a format an AI can actually use — and by extension, makes it available to anyone working in that workspace. The knowledge does not stay locked in one person’s head. The curiosity gets a structure. The structure gets used.

Why this matters for makers

If you have used AI to write Coda formulas, you have probably noticed the pattern. Ask without context and you get formulas that feel like a blend of Excel logic and JavaScript habits — loosely assembled from training content that does not fully reflect how CFL actually works, or how it has evolved. I traced that evolution in detail in an earlier post, but the short version is familiar: Sort().Last() instead of Max(). Technically it runs. Architecturally it reflects an earlier mental model, because that is what most of the older training content looks like.

The AI is not doing anything wrong. It is drawing on what it has seen most. The problem is that Coda’s formula language has its own design logic — closer to set thinking than spreadsheet thinking — and that distinction gets lost when the model fills in the gaps with more familiar patterns.

A Skill File changes that input. Instead of the AI guessing from generic training data, it starts from your standards. The formulas it writes match your naming conventions. The tables it proposes follow your relational logic.

The AI hasn’t changed. Your starting point has.

What a Skill File actually contains

The files we use are split into focused areas — formulas in one file, table architecture in another, page setup separate. The principle is simple: one concern, one file, short enough to be read mid-task. An AI doesn’t need a textbook. It needs a scannable set of decisions it can apply immediately.

Here is a small extract from the formula standards we use:

Use WithName() to avoid calculating the same filtered set twice. Name the result something meaningful and reference it directly rather than repeating the filter expression inside the same formula.

Use Concatenate() when joining two variables. Use Format() when combining three or more — it keeps the expression readable and the placeholders explicit.

These two notes alone will produce formulas that are both faster and easier to read — consistently, across every table the agent touches.

How to start

You do not need a complete system to benefit from this approach. Start with one file. Write down the ten decisions you make automatically — the ones you would explain to a new collaborator on their first day. Table naming, display columns, how you handle blank values, your formula preferences and why.

Over time, those notes become a standard. The standard becomes a library. And the library becomes something you can hand to an AI agent — or a junior builder, or a client — and trust that the work it produces will look like yours. If you want a head start with Skill Files already tested against real Coda workspaces, feel free to reach out.

Once you have that library, the question of sequencing naturally comes up — how to get agents working in the right order across complex tasks. That is what I covered in Coda AI: Leading the Swarm. But in the context of Coda architecture, a Planner only makes sense when grounded in a specific client situation. Steering an agent to build pages, structure data, and write formulas correctly does not require a sequence — it requires the right standards. The Planner becomes relevant once those standards meet a real business process. That is a topic I will return to.

One file is enough to start. The methodology builds from there. The Coda Curious is building toward all of it — one decision at a time.

On a personal note, creating these in-depth posts takes a lot of time and effort. While I love sharing my knowledge, a little support goes a long way. If you found this helpful, what about a donation or sharing this post with your fellow Coda enthusiasts? Every bit of encouragement helps fuel the next deep-dives!

My name is Christiaan, and I regularly blog about Coda. While this article is free, my professional services (including consultations) are not, but I’m always happy to chat and explore potential solutions. You can find my free contributions in the Coda Community and on X. The Coda Community is a fantastic resource for free insights, especially when you share a sample doc.