From FileMaker developer to agentic developer, one rung at a time.

Coding agents aren't new — coding agents that finish the job are. A year ago they demoed well and quit on real work. The last six months crossed the line: they finish, and they test. That's why there are no year-long experts — and why everything in this framework is suddenly possible.

User-facing AI — features you ship to your users: the AI script steps inside FileMaker (semantic find, RAG, embeddings), and the FileMaker Server MCP — your solution's data, exposed to your users' AI assistants.
Developer-facing AI — tools you point at yourself: the ProofKit MCP, the paste loop, this entire framework. An agent that helps you build.

Note the trap: both sides include an MCP server. The category isn't the technology — it's the audience. “Is it an MCP?” tells you nothing; “who does it serve?” tells you everything. (User-facing AI has its own ladder — predictive → generative → agents → agentic, applied inside solutions — but that's a separate curriculum. This framework is the developer side.)

You're allowed to build something, extract the answer, and delete it. Throwaways are a feature, not a failure.

In FileMaker terms: chat is doing all your work in the Data Viewer and never saving. Files are the database. Your knowledge should live in records, not in a scrolling window.

Bonus 1: the files are plain markdown — portable across models and vendors, never hostage to anyone's chat history. Bonus 2: long conversations degrade as they grow; files don't — end the session, the knowledge stays.

Claris publishes ~19,300 help pages in agent-ready Markdown (llms.txt). Grounding beats guessing — lesson one.

MBS 15.4's Clipboard Converter (Sept 2025) watches app switching and converts both directions invisibly. Scripts, script steps, layouts, fields, tables, custom functions, value lists. Free — it's in the unlicensed SyntaxColoring component. One checkbox in preferences.

The point isn't the page — it's the realization. The agent works in a folder, in your environment, creating real files on your machine. That's the mental model Rung 2 builds on (“now imagine the folder pre-loaded with FileMaker knowledge”) — and this little page is the embryo of the web viewer apps at Rung 5.

Spaces in a path are a slow tax: shells need escaping, some build tools and dev servers choke, URLs sprout %20s — and every agent command touching the path gets more fragile. Free to avoid on day one, a real chore to fix after projects point at the path. Bonus: one parent folder makes “what do I point Claude at?” and “what do I back up?” the same easy answer — and one-folder-per-project quietly pre-teaches Rung 2.

Skills teach it how; MCPs let it touch; the desk limits how much it can juggle at once.

Sonnet is not the consolation prize — for the paste loop, script generation, and web viewer work it's excellent. And the upgrade signal is behavioral: when you keep hitting Pro's limits, your own usage is telling you you're ready for Max. Matching the model to the job is a portfolio-stage skill — wonder-stage people run the big model on everything because it's shiny. (Two smaller spend dials live nearby: Effort — faster ↔ smarter, how hard the model thinks — and 1M-context model variants for huge sessions. Same logic: bigger costs more, match it to the job.)

The dial measures how much you trust the environment, not how brave you are. Trust is built: dev copies, files in git, a folder that keeps state — once mistakes are cheap, approving every step just defeats the speed. Beginners on Ask aren't timid; they're correctly calibrated. Veterans on Bypass aren't reckless; they've made mistakes cheap. (Plan mode is the odd one out — not a trust level but a seatbelt: think first, touch nothing.)

You rarely need to touch this — Auto is the default and it mostly manages itself. It's the same arc as the ladder: human-gated until trust is earned.

Yes — you can just chat in Claude Code. Do your discovery there, not in a chat app. People who brainstorm in chat and carry a summary into Code are doing voluntary compaction — a handoff document is a lossy summary, and the nuance dies in it. Talk where the work will happen and every detail of the conversation is still on the desk when building starts.

1 · Context window — the desk. Clearing it is FREE.

2 · Plan usage — the fuel. Refills on a schedule, not on demand.

The desk clears for free; the fuel refills on a schedule; the big models drink from the small tank.

Ride it to 100% and the app compacts — a lossy summary happens to you. Wrap up yourself and you choose what survives. This is files-over-chat as a daily rhythm: fresh starts are free when knowledge lives on disk.

Every sub-agent gets its own context window. They burn their desks so the orchestrator's stays clean — the architectural answer to context limits, where land-the-plane is the habit-level one. The general contractor doesn't get sawdust on his desk; he gets the finished cabinet. (Newer workflow modes go further: sub-agents hand work directly to each other instead of routing every detail back through the conductor.) This is also where your value is heading: as building gets cheap, knowing what to delegate, to whom, with what context becomes the developer's edge.

Watch it live in the Background tasks pane — what used to be a black box is now a window. Seeing delegated agents work is part of how trust gets built.

Setup: empty folder, fresh session. Open the Background tasks pane and the context gauge — note your starting %.

Watch for: sub-agents spawning and running in parallel in the pane — click into one mid-flight. They finish at different times; the orchestrator reconciles the nav and stylesheet across them.

The payoff: check the gauge again. Four pages of work happened and your desk barely grew. The sub-agents' desks are gone — the files remain. That's the orchestra and files-over-chat, proven in one observation on your own machine.

The shared-nav-and-stylesheet requirement is deliberate: independently-built pages must be reconciled, so you see the conductor do real conducting, not just fan-out.

Step 3 is “make it test its work,” turned from a slogan into a pipeline step. Step 4 is why this is the beginner path and direct file patching isn't. There's a name for this discipline: code shaping — agentic coding gets you to a prototype; shaping (review, validate, test, secure) is what gets it to production, and that part stays yours. The paste loop is code shaping in miniature.

A real session: spot a missing field via MCP → add it via OData → refresh MCP to confirm → create the API layout by hand → verify via Data API. Four doors, one task, correct answer.

XML2 still has a known punch list (~8–9 edge cases; multi-file solutions don't process correctly). Claris targets finishing it in 26.1 — alongside native agentic access to scripts, schema, and layouts. Everything below this rung transfers when that lands.

The old wisdom on paper prototypes was psychological, not aesthetic: zero investment means when the client says “that's not it,” you listen instead of defending. AI mockups keep the throwaway psychology and add fidelity — the colors-and-layout conversation happens on day one instead of being postponed. Real-world calibration: a basic search UI in 30–45 min; a full wizard-driven contract-mod prototype, branded with the client's own CSS, in ~4 hours — client's entire reply: “Perfect, build it.”

The honest economics, with the asterisk: it doesn't save time so much as create work that would never have happened — “if it was going to take two days, I wasn't going to do it anyway.” The mockups that exist now are mockups that previously didn't.

The summary says “client wants feature X.” The transcript says the quiet decision-maker wants X now — urgency and nuance live in the full conversation, and the agent reads it for pennies. (Same principle, third appearance: a summary is voluntary compaction.) From there: session logs, “stepping away” at day's end, “what's next?” at day's start — teammates get unstuck by asking the project instead of waiting for the PM. And the byproducts outlive the build: the glossary, business rules, and edge cases the discovery surfaces become permanent context files — every engagement's context compounds into the next one.

Not hypothetical: this framework's own repo runs on exactly these conventions — and the page you're reading was planned from a meeting transcript pulled over MCP. The right expectation, from practitioners a couple of years in: “it hasn't really saved me time — but the quality of our output has gone up.”