Level Up Your Coda + AI Workflow: Free MD Docs Inside!

AI works best when you give it the right context. I’ve been using AI to help write Coda formulas, and feeding it clean documentation makes a huge difference.

So I’m sharing Coda’s docs in Markdown format, ready to drop into ChatGPT, Claude, or any AI tool you use. Whether you’re new to Coda or a longtime user, this will save you time and get you better results.

Every time I wanted AI help with Coda, I found myself trying to fetch and format the docs all over again. It’s not easy to get, and I got tired of repeating the process. So here it is, ready for you to use.

It would be amazing if Coda made documentation easier to access in AI-friendly formats. And if you have other useful MD files or resources that work well with AI, drop them in the comments! Let’s help each other out.

Grab the file below!

- Coda Formula Docs

- Coda Pack Docs

11 Likes

Thank you! I’ve been saying the same thing!!

2 Likes

Thanks a lot @SALEM_MALIBARY ! Have you used that context files with NotebookLM? Which AI do you find the most familiar and successful with Coda?

1 Like

I would be lying if i say i would use coda alot … i usually use coda to understand a concept , then directly use claude code to build micro app to fit my needs …

If i would suggest something interesting and i have done part of it … its making Claude Code interacting with your coda doc , so this way you can provide the file to claude code to write functions for you , to understand your doc / tables and do the whole new columns for you…

There is also someone made Coda MCP its unoffcial which do the same but has layer of understanding better than using raw API calls only.

Anyway, using CLI + Coda would be the most useful way to use those files.

Using these documents for an agentic process is insufficient, and perhaps risky for formula generation because:

  1. Zero Schema Awareness: It forces the agent to guess table/column names (highly predictable hallucination rate).
  2. No Row Context: It fails to teach the critical thisRow / CurrentValue logic.
  3. Language Mixing: It confuses the agent with TypeScript (Packs) vs. CFL (Formulas).

Critique: While Coda IO Packs.txt is actually a high-quality resource for coding a Pack, Coda IO Formula.md is effectively useless for an agent trying to use Coda. It is a dictionary of words for a language the agent doesn’t know the grammar for, applied to a world (your document) it cannot see.

Coda MCP

If you think it through, the only way for Coda MCP to work well is for it to understand how formulas are fabricated. I’m pretty sure Coda MCP can’t build a pack, so we can set that aside for a minute.

But it can build very accurate formulas because it requires deep context from the Coda MCP team. If it can do this in a few seconds, it can probably handle any CFL generation task given sufficient guidance and a schema. Note that the agent decided to create a physical table to resolve my request. This is critical because a CFL without a known schema is unguided and prone to hallucination on every inference.

Given the new agentic processes that are capable of using MCP servers in general (specifically Coda MCP), it’s entirely possible that you’re never going to want to build packs in the future anyway.

Using the Coda MCP (currently in beta) is the only viable path for accurate formula generation.

And if you want to take Coda MCP to a higher level of automation and performance, the mcpOS skillset adds a significant amount of context and logic.

1 Like

Context is the issue of this generation

Indeed, but it requires a few additional predicates. You can bury an agent with seemingly ideal context, and still get some poor results. This is generally the case with contexts that don’t “compile”. Agents, it turns out, run contexts. They don’t just read them.

The core idea—that context quality and structure matter more than sheer volume—is well-supported in current AI research and engineering practices. Even with “near ideal” (i.e., comprehensive and relevant) context provided, agents can fail if the context isn’t organized in a way that’s easy for the model to process and act upon effectively.

Key Reasons

  • Agents actively “execute” or “run” context: Unlike simple query-response LLMs that mostly read and summarize, agents operate in loops: they reason over the context, decide on actions/tools, observe results, and iterate. Poorly structured context (e.g., redundant, conflicting, or “uncompilable” information) leads to errors like getting “lost in conversation,” premature conclusions, or failure to recover from mistakes. This is echoed in papers and blogs on “context rot,” “lost in the middle,” and agent failures despite long context windows.

  • The “compile” metaphor: Some frameworks describe context management as “compiling” a view of state for the LLM—separating storage from what’s presented, ensuring relevance, and avoiding overload. Inconsistent or non-actionable context doesn’t “compile” cleanly, causing degraded performance.

This nuance explains why context engineering (curating, compressing, retrieving, and isolating information) has become a critical skill for building reliable agents, often outweighing raw context size.

If you examine the mcpOS skill, you’ll discover several compileable attributes in the Markdown document.

They are structural and procedural elements that make the context easy for an AI agent to reliably “execute” or “run” like clean, deterministic code rather than ambiguous natural language. These features reduce interpretation errors, enforce predictable flows, and prevent common failure modes.

1. Strict ID Resolution Pipeline (Law I)

  • The context defines a mandatory, step-by-step mechanism: Search → Disambiguate → Lock ID.
  • This is “compilable” because it turns an ambiguous human request (“add to Tasks table”) into a deterministic sequence that always resolves to a unique tableId, pageId, or rowId.
  • Without this, the agent would have to guess or hallucinate IDs. With it, the agent can execute a fixed subroutine before any write operation.

2. Schema Inspection Before Mutation (Law II)

  • Every write operation is gated behind a mandatory schema audit: check format, isFormula, lookup relations, and select-list options.
  • This compiles because it transforms potentially invalid inputs (e.g., writing a string to a relation column) into guaranteed valid ones (resolve to rowId, map to allowed option).
  • The agent doesn’t need to “hope” the write succeeds; it can validate upfront like a type checker in code.

3. Immediate Post-Action Verification (Law III)

  • After every mutation, the agent must read back the exact changed entity to confirm state.
  • This creates a closed feedback loop: Action → Observe → Match Intent.
  • Compilable because it turns potentially flaky API calls into verifiable atomic transactions. If the read-back doesn’t match, the agent can retry or escalate deterministically.

4. Standard Operating Procedures (SOPs) as Reusable Subroutines

  • SOP-01 (Smart Upsert), SOP-02 (Context Evaluation), SOP-03 (Schema Defense) are written as explicit numbered steps with branching logic.
  • These function like functions or macros the agent can “call” for common tasks.
  • The structure (Resolve → Query → Branch → Execute) is unambiguous and executable without additional reasoning, reducing context interpretation overhead.

5. Token Economy Rules with Concrete Thresholds (Law IV)

  • Hard rule: never read tables >50 rows; always peek rowCount first and slice.
  • Compilable because it provides a clear decision boundary and prescribed alternatives (use search or filtered reads).
  • Prevents the common “lost in massive context” failure mode by enforcing pagination at the protocol level.

6. Tool Matrix with Cost and Constraints

  • The table explicitly maps intent → tool → cost → mandatory notes.
  • This acts like an API routing table: for a given goal, there’s a prescribed tool and constraints (e.g., pagination mandatory for table_read_rows).
  • The agent can “compile” a plan by looking up the correct tool path rather than reasoning from scratch each time.

7. Dual-View and Audit Log Capabilities as Side-Effects

  • Features like writing to _ai_context sub-pages or mandatory _Agent_Audit_Log entries are defined as automatic side-effects of certain operations.
  • These make the context self-documenting and self-optimizing over multiple turns, turning one-off interactions into stateful, traceable programs.

In summary, what makes this context highly “compilable” is that it replaces open-ended natural language instructions with rigid laws, numbered procedures, decision trees, mandatory pre- and post-conditions, and lookup tables. An agent can treat these as executable pseudocode rather than needing to interpret vague intent, dramatically improving reliability and consistency.

1 Like

The presumption is all frontier models prefer Markdown. I thought so too.

While building several micro-agents in Coda, my clients and I have had ample opportunity to experiment with different document types and formats across a few LLMs (Gemini, GPT, Perplexity).

We have found that the document format can indeed have a significant impact on the model’s ability to ‘understand’ the information and provide an accurate response.

We are injecting approx 200kB pages into our prompts as a kind of ‘poor mans’ RAG solution. (This way, we can use native Coda pages for our knowledge base instead of an external Vector DB).

Top of the list for best results is YAML. This is best for highly structured information where we would normally use JSON to provide a strict structure. But JSON consumes a LOT more tokens and we get far more ‘lost the plot’ errors - Gemini and GPT seem to follow complex YAML better.

Next is Markdown-formatted human-oriented text. The emphases given by various headings, the structure given by indented lists (numbered or not) and the convenience and clarity provided by tables all contribute to the model’s ability to ‘follow the plot’ and understand the content.
BUT - the style and language used in the documents has a big impact (see below).

Richly formatted pages imported from MS Word, Google Docs, RTF tools etc. (and richly formatted native Coda pages) come next - but in practice, these are probably converted internally to Markdown before being injected into the context window.

Even when using Vector Databases, we found PDFs to be terrible. The PDF data structure encodes positioning and font-setting for the text, but loses the human-readable structure, such as headings, indentations, bullet lists, table layouts, etc. We find we need to track down the original docs and use them instead. (Andrew Ng has set up a company to address this with PDFs).

We found that PowerPoint and other presentation formats are best imported into Coda as rich text first, so they are presented to the LLM as a set of sections within a page (we do not yet have a way to understand the pictures, but we expect that to be fixed soon).

The other dimension we have found that matters greatly is the Style or Language used in these documents.

Top of the list for clarity are technical specifications and ‘how-to’ documents; Procedure definitions, Checklists, Training documents, Corporate Wikis, etc. These have clear, precise, uncluttered language, focused on delivering good understanding with minimal ‘fluff’.

Next on the list are well-crafted narrative docs like articles, journalism, management reports, official memos, etc. Professional, impersonal language with a clear purpose.

Not so useful are transcripts of meetings, message threads from Slack, WhatsApp, Discord, or Email threads. These contain a lot of ‘chatter’ and emotive language that detracts from the clarity of purpose. They can be used. They work. Just not as effectively.

And worst of all (in our experience) are marketing and sales documents, which seem to sugar-coat everything with salesmanship and overly flowery descriptions. The LLM is naive and gullible and swallows this stuff whole with great credulity. It works if you want the agent to persist in the propaganda, but it’s not great for executing strictly business operations.

Of course, all this is changing rapidly. So by the time you read this, it is probably out of date. And, as always, your mileage may vary.

But I wanted to share our hard-won experience, because the LLM Labs seem not to want us to know the weaknesses or limitations of their technology.

Respect,
:red_circle:➤𝖒𝖆𝖝

2 Likes

I should have added a point about using SPREADSHEETS in this way.

Spreadsheets that are mostly numeric values are TERRIBLE to use for LLMs because they do NOT understand numeric data. They understand language, words, sentences, concepts, etc. Pure numeric data is not understandable to them at all.

For these types of information we need to build our own ML Neural Networks using tools like Google Tensorflow - then we can train those neural nets with the numeric data so it can learn the underlying patterns in the data - then the neural net can classify inputs or predict values based upon the learned patterns.

But Spreadsheets that organise textual information ARE easy for the LLMs to understand.

1 Like