<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Transforming Digital - Medium]]></title>
        <description><![CDATA[We build production AI — transcription, extraction, semantic search — that runs entirely on our clients’ infrastructure. We write about what the work teaches: continuous-improvement discipline for AI adoption, the engineering underneath, and where hype parts company with help. - Medium]]></description>
        <link>https://medium.com/transforming-digital?source=rss----ae52702e0e12---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Transforming Digital - Medium</title>
            <link>https://medium.com/transforming-digital?source=rss----ae52702e0e12---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 01:47:47 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/transforming-digital" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Stop Correcting Claude's FileMaker Scripts: Use a Skill to Enforce Your Conventions]]></title>
            <link>https://medium.com/transforming-digital/stop-correcting-claudes-filemaker-scripts-use-a-skill-to-enforce-your-conventions-b09640526ea2?source=rss----ae52702e0e12---4</link>
            <guid isPermaLink="false">https://medium.com/p/b09640526ea2</guid>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[filemaker]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[claris]]></category>
            <dc:creator><![CDATA[Ian Jempson]]></dc:creator>
            <pubDate>Sun, 12 Jul 2026 10:49:32 GMT</pubDate>
            <atom:updated>2026-07-13T12:06:06.246Z</atom:updated>
            <content:encoded><![CDATA[<h3>Teaching Claude Your FileMaker Way: Using Skills to Enforce Scripting Conventions</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q7Xx3lvPCx1JbaAwhuterg.png" /></figure><p>If you’ve handed a FileMaker task to Claude lately, you’ve probably had this moment: the script it wrote <em>works</em>, but it isn’t how you’d have written it. The steps are in a defensible order, the logic is sound, and yet it quietly ignores a convention you’d never break yourself.</p><p>Someone asked about this on a recent FMDiSC meeting. They asked for a Find script, and Claude produced one that went to the layout first and <em>then </em>entered Find mode. He prefers the reverse: enter Find mode first, then switch to the layout. On his team that ordering is house style. Claude didn’t do anything wrong. It just didn’t do it <em>his</em> way.</p><p>Which convention is faster isn’t the point of this post. The point is that you can use Claude Skills to have it write code that conforms to the scripting conventions that you prefer.</p><h3>Why Claude doesn’t already know your convention</h3><p>FileMaker is a small world compared to the languages Claude has seen the most of. There is vastly less public FileMaker code than there is Python or JavaScript, and what exists isn’t always consistent. Two experienced developers will write the same Find script two different ways and both will defend their choice. There is no single canonical “right answer” in the training data for Claude to converge on.</p><p>So when you ask for a Find script, Claude picks a reasonable default. Reasonable might not the same as <em>yours</em>. You can correct it in the prompt every time (adding “remember to enter Find mode before going to the layout”), and that works, right up until you forget, or a teammate phrases it differently, or you run the task fresh next week and the instruction is gone. Prompting is per-conversation and it drifts. You need something that persists and applies itself.</p><h3>The right tool for the job is a skill</h3><p>A skill is a small, reusable bundle of instructions that Claude loads on demand. Instead of re-explaining your preference in every chat, you write it down once, and Claude picks it up automatically whenever the task calls for it. The effect is to turn “please remember to…” into a rule that fires every time.</p><p>Here’s the useful part for proving the point. To show that the <em>skill</em> is doing the steering, not clever prompting or luck, I built the same capability two ways. Two skills, identical in every respect except the one convention they enforce. Same request to Claude in both cases. If the output flips to match whichever skill is loaded, the skill is the thing in control.</p><h3>Two skills, two conventions</h3><p><strong>Skill A, layout-first.</strong> This is the default many of us see Claude produce: go to the layout, then enter Find mode.</p><pre>---<br>name: fm-find-layout-first<br>description: Write FileMaker Pro Find scripts using the layout-first convention (Go to Layout, then Enter Find Mode, then set criteria, then Perform Find). Use whenever generating any FileMaker script that performs a find.<br>---<br><br># FileMaker Find scripts: layout-first convention<br><br>When you write any FileMaker Pro script that performs a find, use the ordering<br>below. Do not reorder these steps.<br><br>## Required step order<br><br>1. Set Error Capture [ On ], to trap the &quot;no records found&quot; error yourself.<br>2. Go to Layout [ ... ], to navigate to a layout tied to the correct table<br>   occurrence before changing mode.<br><br>3. Enter Find Mode [ Pause: Off ].<br>4. Set Field [ ... ], one step per find criterion.<br>5. Perform Find [ ].<br>6. Handle the result by testing Get ( FoundCount ).</pre><p><strong>Skill B, find-mode-first.</strong> Same script, one difference: enter Find mode before navigating.</p><pre>---<br>name: fm-find-mode-first<br>description: Write FileMaker Pro Find scripts using the find-mode-first convention (Enter Find Mode, then Go to Layout, then set criteria, then Perform Find). Use whenever generating any FileMaker script that performs a find.<br>---<br># FileMaker Find scripts: find-mode-first convention<br>When you write any FileMaker Pro script that performs a find, use the ordering<br>below. Do not reorder these steps.<br>## Required step order<br>1. Set Error Capture [ On ], to trap the &quot;no records found&quot; error yourself.<br>2. Enter Find Mode [ Pause: Off ], to enter Find mode before navigating.<br>3. Go to Layout [ ... ], to switch to a layout tied to the correct table<br>   occurrence while already in Find mode.<br>4. Set Field [ ... ], one step per find criterion.<br>5. Perform Find [ ].<br>6. Handle the result by testing Get ( FoundCount ).</pre><p>Each skill also has some things you’d expect to see: reference a layout tied to the correct table occurrence, pair Set Error Capture [ On ] with a Get ( FoundCount ) check, keep criteria in scripted Set Field steps rather than stored requests. The <em>only</em> thing that differs between them is the order of two steps. Yes, it’s incomplete but its enough to demonstrate the point.</p><h3>Same request, opposite output</h3><p>Now the same prompt to Claude (<em>“Write a FileMaker script that finds all active contacts”</em>) with each skill loaded in turn.</p><p>With <strong>fm-find-layout-first</strong> loaded:</p><pre>Set Error Capture [ On ]<br>Go to Layout [ &quot;Contact_Find&quot; (Contact) ]<br>Enter Find Mode [ Pause: Off ]<br>Set Field [ Contact::Status ; &quot;Active&quot; ]<br>Perform Find [ ]<br>If [ Get ( FoundCount ) = 0 ]<br>    Show Custom Dialog [ &quot;No active contacts found.&quot; ]<br>End If</pre><p>With <strong>fm-find-mode-first</strong> loaded:</p><pre>Set Error Capture [ On ]<br>Enter Find Mode [ Pause: Off ]<br>Go to Layout [ &quot;Contact_Find&quot; (Contact) ]<br>Set Field [ Contact::Status ; &quot;Active&quot; ]<br>Perform Find [ ]<br>If [ Get ( FoundCount ) = 0 ]<br>    Show Custom Dialog [ &quot;No active contacts found.&quot; ]<br>End If</pre><p>Lines two and three swap, and nothing else moves. The request never changed. The model never changed. The only variable was which skill we used and that is what determined the convention.</p><h3>Why a toy example is the right example</h3><p>Finding on Contact_Find for active contacts is deliberately trivial, and the layout-versus-mode debate is clearly one where reasonable people disagree. That&#39;s what makes it a good test. Because the two scripts are nearly identical, the one thing the skill changed is impossible to miss. Strip the example down far enough and the mechanism stands out on its own: you are not re-arguing with Claude about conventions, you are configuring which convention it uses.</p><h3>The full-fat version: a skill that ships production code</h3><p>The two skills above each change one thing, which is what makes the demo clear. But a skill can carry as much of your standard as you want. Here’s a third one: same find-mode-first ordering, but now it also enforces a standardised comment header and real error handling. This is closer to what you’d actually put in front of your team. Yes, I know that it’s missing a lot, but it’s a quick example and it’s sunny and 31 degrees in London so I don’t want to spend my whole afternoon on this!</p><pre>---<br>name: fm-find-mode-first-full<br>description: Write production-grade FileMaker Pro Find scripts using the find-mode-first convention, with a standardised comment header and error checking after entering Find mode and changing layouts.<br>---<br><br># FileMaker Find scripts: production-grade, find-mode-first<br><br>## 1. Standardised comment header<br>Every script begins with a header built from # comment steps:<br>Script, Purpose, Parameters, Returns, Author, Created, Modified, Version, Notes.<br>Use ISO dates; bump Version and add a Modified line whenever the logic changes.<br><br>## 2. Find step order (find-mode-first)<br>Set Error Capture [ On ], Enter Find Mode, confirm the switch,<br>Go to Layout, Set Field, Perform Find.<br><br>## 3. Error checking<br>The critical check is right after Enter Find Mode. Entering Find mode commits the<br>current record, and that can be blocked (an uncommitted record failing<br>validation, a locked record). If the switch fails silently you are still in<br>Browse mode, and the next Set Field overwrites live data. Confirm with both<br>Get ( LastError ) ≠ 0 and Get ( WindowMode ) ≠ 1 (1 = Find mode); if either<br>fails, report and Exit Script before touching a field. After Perform Find, treat<br>error 401 or a zero FoundCount as an empty result. Always Exit Script with a<br>status the caller reads.</pre><p>The same prompt as before (<em>“Write a FileMaker script that finds all active contacts”</em>) now produces this:</p><pre># ============================================================<br># Script:      Find Active Contacts<br># Purpose:     Return a found set of all contacts with Status = &quot;Active&quot;<br># Parameters:  none<br># Returns:     0 = success ; 401 = none found ; other = FileMaker error<br># Author:      J. Developer<br># Created:     2026-07-11<br># Modified:    2026-07-11 by J. Developer, initial version<br># Version:     1.0.0<br># Notes:       Find-mode-first convention. Aborts safely if Find mode can&#39;t be entered.<br># ============================================================<br><br>Set Error Capture [ On ]<br>Enter Find Mode [ Pause: Off ]<br>If [ Get ( LastError ) ≠ 0 or Get ( WindowMode ) ≠ 1 ]<br>    Set Variable [ $error ; Value: Get ( LastError ) ]<br>    Show Custom Dialog [ &quot;Could not enter Find mode (error &quot; &amp; $error &amp; &quot;). Check for an uncommitted or locked record.&quot; ]<br>    Exit Script [ Text Result: $error ]<br>End If<br>Go to Layout [ &quot;Contact_Find&quot; (Contact) ]<br>Set Field [ Contact::Status ; &quot;Active&quot; ]<br>Perform Find [ ]<br>If [ Get ( LastError ) = 401 or Get ( FoundCount ) = 0 ]<br>    Show Custom Dialog [ &quot;No active contacts found.&quot; ]<br>    Exit Script [ Text Result: 401 ]<br>End If<br>Exit Script [ Text Result: 0 ]</pre><p>Notice the error check that matters most for this convention. Because we enter Find mode <em>before</em> navigating, everything downstream assumes the mode switch actually happened. But Enter Find Mode commits the current record first, and that commit can be blocked (an uncommitted record failing validation, a locked record), leaving you silently stuck in Browse mode. If the script pressed on, the next Set Field [ Contact::Status ; &quot;Active&quot; ] wouldn&#39;t enter a find criterion; it would overwrite the Status of a live record. So the skill traps it immediately, checking both Get ( LastError ) and Get ( WindowMode ) before it goes anywhere near a field. The comment header lands automatically, fully populated, on every script the skill touches. Nobody had to remember any of it.</p><h3>How about editing scripts?</h3><p>The potentially bigger use for a skill like this is that you can give it a pre-existing script and ask Claude to fix it. I do this frequently. I’ll rough out an Insert From URL script with the correct parameters then ask Claude to “fix this script”. I goes off, makes it conform to my conventions, adds all the tedious boilerplate stuff, and fills in the boring bits like the script headers that I often forget to update.</p><h3>Where this goes in real work</h3><p>Again, ordering two Find steps is a toy demo. The same technique works on anything your team has an opinion about: your error-handling pattern, your script-parameter and JSON conventions, how you name layouts and table occurrences, your commenting style, your preferred navigation idioms, whether every subscript sets and restores error capture. Written as a skill, or a small set of them, those conventions become a shared style guide that every developer’s Claude reads from. One source of truth, consistent output, no one relying on memory or on re-typing the same correction.</p><h3>The takeaway</h3><p>When Claude writes FileMaker the “wrong” way, that’s not a wall. It’s a hint that you should stop and capture what “right” means on your team. Do it once, as a skill, and stop correcting the same thing forever.</p><p><em>I write a weekly newsletter on putting AI into real business systems, mostly FileMaker, mostly running locally. Free, and I write it myself: </em><a href="https://ianjempson.substack.com/subscribe"><em>subscribe</em></a><em> at ianjempson.substack.com.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b09640526ea2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/transforming-digital/stop-correcting-claudes-filemaker-scripts-use-a-skill-to-enforce-your-conventions-b09640526ea2">Stop Correcting Claude&#39;s FileMaker Scripts: Use a Skill to Enforce Your Conventions</a> was originally published in <a href="https://medium.com/transforming-digital">Transforming Digital</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Your FileMaker Semantic Search Is Fast. Is It Right?]]></title>
            <link>https://medium.com/transforming-digital/your-filemaker-semantic-search-is-fast-is-it-right-59d4f8a50f49?source=rss----ae52702e0e12---4</link>
            <guid isPermaLink="false">https://medium.com/p/59d4f8a50f49</guid>
            <category><![CDATA[semantic-search]]></category>
            <category><![CDATA[vector-embeddings]]></category>
            <category><![CDATA[filemaker]]></category>
            <category><![CDATA[rags]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Ian Jempson]]></dc:creator>
            <pubDate>Tue, 07 Jul 2026 10:39:32 GMT</pubDate>
            <atom:updated>2026-07-13T12:06:50.399Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Tpb8lAVSEG2QyL5I5N6_oQ.png" /></figure><h3>Your Semantic Search Is Fast. Is It Right?</h3><p><em>Measuring FileMaker search quality with evals, then improving it with chunking, a better model, and a reranker</em></p><p>In a <a href="https://medium.com/transforming-digital/filemaker-semantic-search-40x-faster-with-hybrid-techniques-3acb8d9f470f">previous post,</a> we took a semantic search over 900,000 records from 80 seconds down to 2. Speed matters, but it’s only half the problem. A fast search that returns the wrong records is just a faster way to disappoint your users.</p><p>So this post asks the other question: how do you know your search is returning the <em>right</em> results, and once you can measure it, how do you improve it?</p><p>I tested this on a hosted FileMaker file and a local embedding server, scoring every change against a fixed set of 123 questions with known answers. A handful of changes made significant improvements.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/708/1*frXBx8hTuucKtmSshSZu0Q.png" /></figure><p>Here’s how I made those changes, starting with the simplest one first.</p><h3>The short version: what actually makes a difference</h3><p>Here are my suggestions for how to improve your semantic search in FileMaker.</p><p><strong>1. Upgrade your embedding model, and check its context window.</strong> <br>This is the easiest win and the one everyone can take. If you do nothing else, do this. In FileMaker it is a single line: point Configure AI Account at a newer model, with nothing else in your solution touched. Moving from all-MiniLM to a current model lifted the right-answer-first rate from 33% to 43% on its own. Just as important, old models often have tiny context windows: MiniLM silently discards everything past 128 tokens, about 520 characters, so most of every longer chunk was thrown away before it was ever embedded. Check the model’s max_seq_length before you trust it with anything longer than a sentence.</p><p><strong>2. Add a reranker.</strong></p><p>The single biggest lever in the whole experiment. A reranker is a second, more careful model that re-reads your query against each candidate result and reorders them: you let the fast semantic find fetch 50 candidates, then let the reranker pick the best 10. It improved every configuration I tested, by 9 to 19 points of first-hit rate, and it needs no re-indexing, no new records, no schema changes. It is one extra Insert from URL call after Perform Semantic Find: pure query-time work, and it stacks on top of everything else.</p><p><strong>3. Chunk with the structure your documents already have.</strong></p><p>How you split documents into chunks sets the ceiling the model and reranker work under, and generic splitters throw away information you already have. Many essays look like plain prose, but most have named sections, footnotes, and clean paragraph breaks, and a chunker that respects those beat every one-size-fits-all method. Your data has structure too: invoices have line items, contracts have clauses, meeting notes have agenda points. Respect it before reaching for anything exotic.</p><p><strong>4. Don’t pay for the exotic options.</strong></p><p>Two impressive-sounding levers earned nothing here. “Semantic” chunking, which groups text by topic similarity, finished last in every single test across four different embedding models. That came as a huge surprise to me as I expected it to perform best. And a large 32,000-token context window, against an ordinary 512-token one, made no measurable difference once the chunks already fit. Spend the effort on the three levers above instead.</p><p>And underpinning all four: <strong>measure everything.</strong> None of these conclusions would be trustworthy, and one of them would have been flat wrong, without a proper evaluation set: a few hundred questions with known answers, so you can see whether a change helped, hurt, or did nothing, instead of eyeballing a handful of queries and hoping. That measurement is what the rest of this post builds, and it is where every number above comes from. It’s important to point out that your dataset is different and you might see different results, hence the importance of running your own evaluations.</p><h3>The test corpus: Paul Graham’s essays</h3><p>The retrieval world has an unofficial standard test corpus: Paul Graham’s essays. LlamaIndex uses them in its documentation, Arize used them for the needle-in-a-haystack tests, and reranker benchmarks include them as a long-form corpus. 215 essays (about 2.9 million characters) is big enough for retrieval quality to genuinely vary, and small enough to embed locally in minutes.</p><p>I loaded all 215 essays into a hosted FileMaker file: an Essays table with id, title, date, and text. If you want to follow along, there is a ready-made dataset on Hugging Face (<a href="https://huggingface.co/datasets/sgoel9/paul_graham_essays">sgoel9/paul_graham_essays</a>).</p><h3>You cannot improve what you cannot measure</h3><p>Most people evaluate search the same way: type a few queries, eyeball the results and call it a day. That works until you change something, because then you need to know whether the change helped, hurt, or did nothing, across all the kinds of queries your users make. Eyeballing does not scale to that. An evaluation set does.</p><p>The methodology comes from Chroma’s excellent <a href="https://www.trychroma.com/research/evaluating-chunking">technical report on chunking strategies</a>: use an LLM to generate questions from randomly sampled passages, record exactly which passage each question came from, and score retrieval by whether the search brings back a chunk that overlaps that golden passage.</p><p>For each question we store the essay it came from and the character positions of the excerpt that answers it. Every chunk we create later also carries its character positions, so scoring is mechanical: a retrieved chunk is a hit if it comes from the right essay and its character range overlaps the golden excerpt.</p><p>I generated 150 candidate questions with a local model (gemma4 running in Ollama), prompted to write questions the way a real person would type them into a search box. Two examples:</p><blockquote><em>“What simple measure can prevent advanced filters from catching bulk mail messages?”</em></blockquote><blockquote><em>“Why is it beneficial for early employees to accept low salaries?”</em></blockquote><h3>Filter your synthetic questions</h3><p>Don’t trust an LLM-generated eval set blindly. Some generated questions are garbled, and some are not actually answerable from the passage they were generated from. If those stay in, they add noise to every number you compute afterwards.</p><p>So the 150 candidates faced a judge: an LLM that saw each question with its source passage and answered one thing, does this passage clearly answer this question, yes or no. A small strict judge dropped 36. Because strict judges also make mistakes, the 36 rejects got an appeal in front of a stronger model, which restored 9. My final set was123 questions, each verified answerable from its recorded passage.</p><p>That two-stage pattern (cheap strict judge for the bulk pass, stronger judge for appeals) is easy to copy and costs a few minutes of local inference.</p><h3>The metrics</h3><p>Three metrics, all computed over the 123 questions:</p><ul><li><strong>Recall@k</strong>: the fraction of questions where a correct chunk appears in the top k results. If your search feeds a RAG prompt with five chunks of context, Recall@5 is literally “how often does the model receive the answer.”</li><li><strong>MRR (mean reciprocal rank)</strong>: rewards position. A correct first result scores 1, second place scores 1/2, tenth place 1/10. This is the metric that notices when the right answer moves from rank 8 to rank 1.</li><li><strong>Essay Recall@5</strong>: did we at least reach the right essay? The gap between this and passage-level recall tells you whether your problem is retrieval (wrong essay entirely) or chunking (right essay, wrong slice of it).</li></ul><p>One calibration note before any results: with 123 questions, each question moves a recall figure by 0.8 points, and differences under about 4 points are within noise. Keep that in mind as the tables go by. More questions in the test set would reduce the noise level.</p><h3>The architecture</h3><p>I used FileMaker as the database and the search engine. Its native script steps do the heavy lifting:</p><ul><li><strong>Configure AI Account</strong> points at a local OpenAI-compatible embedding server instead of OpenAI itself. Same script steps, no API bill, no data leaving the building.</li><li><strong>Insert Embedding in Found Set</strong> embeds the chunks in batches.</li><li><strong>Perform Semantic Find</strong> runs the search and returns the found set sorted by cosine similarity.</li></ul><p>The Python side is one small FastAPI server with three endpoints:</p><ul><li>POST /chunk: takes essay text and a method name, returns chunks with their character offsets. FileMaker calls it with Insert from URL and creates one Chunks record per chunk.</li><li>POST /v1/embeddings: an OpenAI-compatible wrapper around a local sentence-transformers model. This is what Configure AI Account points at, and it is what will let us swap embedding models later by changing one environment variable, with zero changes in FileMaker.</li><li>POST /rerank: takes a query and candidate texts, returns them reordered by a cross-encoder. More on this later.</li></ul><p>The FileMaker schema is three tables: Essays, Questions, and a Chunks table with essay_id, config, chunk_index, start, end, chunk_text, and an embedding container field. The config field is the trick that makes comparison easy: chunks from every strategy coexist in one table, and each eval run constrains the found set to one config before searching.</p><p>The eval loop is a script that walks the Questions table, performs a semantic find over one config’s chunks, and writes the top ten results per question to a JSON file. A small Python script scores those files against the golden set.</p><h3>Five chunking strategies</h3><p>Chunking decides what a “result” even is. Embed whole essays and a single vector has to summarise 10,000 words, which works about as well as describing a novel in one sentence. If the chunks are too small each piece loses the context that gives it meaning. Between those extremes there is real room for skill, and FileMaker gives you no control over any of it, which is why the chunking happens server-side where we can choose.</p><p>The five configs, loosely following Greg Kamradt’s <a href="https://github.com/FullStackRetrieval-com/RetrievalTutorials/blob/main/tutorials/LevelsOfTextSplitting/5_Levels_Of_Text_Splitting.ipynb">five levels of text splitting</a>:</p><ol><li><strong>fixed_512</strong>: split every 512 characters. The naive baseline. 5,842 chunks.</li><li><strong>fixed_512_ov64</strong>: same, with 64 characters of overlap. 6,643 chunks.</li><li><strong>recursive_800</strong>: split on paragraph boundaries first, then sentences, up to 800 characters. The strategy Chroma found consistently strong. 5,012 chunks.</li><li><strong>structural_800</strong>: document-aware splitting, described below. 5,105 chunks.</li><li><strong>semantic_p90</strong>: embed each sentence and start a new chunk where the similarity between neighbouring sentences drops sharply. The most sophisticated method here, and the most expensive. 3,229 chunks.</li></ol><h3>Even “unstructured” text has structure</h3><p>The structural config came from actually looking at the corpus. Paul Graham’s essays look like plain prose, but 151 of the 215 have named sections marked with bold headers, 129 have a Notes section of footnotes, and nearly all have clean paragraph breaks.</p><p>Generic splitters throw that structure away. The structural chunker keeps it: split on section headers, pack whole paragraphs into chunks up to the size limit, and never let a chunk cross a section boundary. Footnotes stay in footnote chunks instead of bleeding into body text.</p><p>Your data has structure too: invoices have line items, meeting notes have agenda points, contracts have clauses. Before reaching for exotic chunking, respect the structure your documents already have.</p><h3>Chunking: structure beats sophistication</h3><p>Each config was chunked, embedded with all-MiniLM-L12-v2 (the default on FileMaker Server), and evaluated over all 123 questions. These MiniLM numbers come with an asterisk we will quantify shortly, because this 2021 model was quietly truncating the longer chunks, but the ranking they establish holds up under every model that follows.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cHFRnWA6uaibOQyvvLXDHg.png" /></figure><p>The baseline is worse than you would guess: naive chunking puts the right passage in the top five results 58% of the time. Two queries in five, the answer the user needed was not there.</p><p>Structure-aware chunking wins, modestly: structural has the best first-hit rate and MRR, recursive close behind. This is recommendation 3 in a single table, and the margin grows once the reranker and a better model come into play.</p><p>And the result that recommendation 4 warned about: <strong>semantic chunking lost, to everything, including the naive baseline</strong>, scoring seven points of Recall@5 below splitting every 512 characters. The most sophisticated and most expensive method here finished last. That verdict looks unfair at this stage, because MiniLM’s truncation hit semantic’s large chunks hardest, so we will return and re-run it on a level field to see if that problem persists.</p><h3>The reranker: the biggest single lever</h3><p>This is the change that moved the numbers most.</p><p>Semantic search with embeddings is a bi-encoder: the query and each document were embedded separately, and similarity is a single dot product between two summaries. It is blazingly fast, and FileMaker’s Perform Semantic Find does exactly this. But it never reads the query and the document <em>together</em>.</p><p>A cross-encoder reranker does. It takes the query and one candidate chunk as a pair and reads them jointly, which lets it notice things a similarity score cannot, at the cost of being far too slow to run against every record. The standard pattern is to let the fast search retrieve 50 candidates, then let the careful model reorder them and keep the top 10.</p><p>In FileMaker this is one extra Insert from URL call after Perform Semantic Find. We send the question and the 50 candidate chunk texts to the local /rerank endpoint and get back the reordered indexes. The reranker here is ms-marco-MiniLM-L-6-v2, a small cross-encoder that runs comfortably on CPU.</p><p>Every config, with and without reranking:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Fl4lohDgPQ3zJzXzo8Ekkw.png" /></figure><p>Two findings, and they both survive everything that follows:</p><p><strong>Reranking improved every single config</strong>, by 9 to 19 points of first-hit rate. It is the most reliable lever in the whole experiment, and it required no re-indexing, no new records, and no schema changes. It does require an extra Insert from URL call.</p><p><strong>But it did not rescue bad chunking.</strong> Reranked semantic chunking still finishes last. A reranker can only reorder what retrieval put in the top 50; if the right chunk never surfaced, there is nothing to promote. Chunking and reranking are complementary layers, not substitutes.</p><h3>Chunk size, and the hidden constraint behind recommendation 1</h3><p>Recommendation 1 came in two parts: upgrade the model, <em>and</em> check its context window. This is the section that earns the second part, and it starts with an experiment on chunk size. Does chunk size matter on the naive fixed-size system? I created four more configs, ranging from 128 to 2,048 characters:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/568/1*yjcyr_tANHMde1rcYGBHDA.png" /></figure><p>The results are an inverted U shape, peaking at 512. Small chunks are context-starved fragments, which is unsurprising. Large chunks are where it gets interesting. The obvious explanation is dilution: a longer chunk’s embedding has to average over more ideas, blurring the passage you are looking for. But dilution is gradual, and the collapse at 2,048 is not: sixteen points of Recall@5 below the peak. That looks more like a hard limit rather than a soft trend.</p><p>We can see the reason on the embedding model’s card:</p><pre>&gt;&gt;&gt; SentenceTransformer(&quot;all-MiniLM-L12-v2&quot;).max_seq_length<br>128</pre><p>The model’s maximum input is 128 tokens: roughly 520 characters. Everything past that in a chunk is silently thrown away before embedding. Not summarised or compressed. Just discarded, with no warning.</p><p>So the size curve makes perfect sense. fixed_512 did not win because 512 characters is a magic number; it won because it is the largest size that fits this particular model’s window. fixed_1024 was half invisible to the search. fixed_2048 was mostly invisible.</p><h3>How much text the model never saw</h3><p>Tokenising every chunk of every config shows exactly how much text the model never saw:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HWS2zSAWxu0Ks5DlVcoVSA.png" /></figure><p>Look at that last row again. <strong>Nearly half of the semantic config’s text was never embedded at all.</strong> Meanwhile recursive and structural posted their chunking results carrying a 13 to 14% handicap, and fixed_512, the apparent “winner” of the size sweep, was the only configuration the model actually saw in full.</p><p>This is why our first recommendation pairs “upgrade the model” with “check its window”, and it is the most important argument in the post for measuring properly. The eval alone could not catch this, because every config was scored by the same rules: the numbers were internally consistent and externally wrong. It took the eval <em>plus</em> an audit of the pipeline’s hidden constraints. Every chunking verdict up to this point was contaminated, and the only way to fix it is to re-run everything on a model that can see the whole chunk.</p><p>So make sure to check max_seq_length before you choose a chunk size. It is one line of Python, and skipping it cost this pipeline up to sixteen points of recall with no warnings to the user.</p><h3>Re-running on a model that sees the whole chunk</h3><p>Because FileMaker talks to a local OpenAI-compatible server, swapping the embedding model needs no FileMaker changes at all. Just restart the server with bge-small-en-v1.5 (a current-generation small model with a 512-token window, four times that of MiniLM), re-run the embed step, re-run the eval. Under the bigger window, every config now fits, even semantic’s largest chunks.</p><p>This answers two questions at once: does the model matter, and was truncation really the mechanism?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OEGfAYDdcYE7TyjQwHWhGg.png" /></figure><p><strong>The model matters, a lot.</strong> Every config improved on every metric, by 3 to 11 points. Swapping a 2021 embedding model for a 2023 one was worth roughly as much as the best chunking change, and the two improvements stack.</p><p><strong>The truncation mechanism is confirmed.</strong> Under MiniLM, fixed_1024 trailed fixed_512 by nearly six points of Recall@5. Under BGE, with the whole chunk finally visible, the penalty vanishes: fixed_1024 matches fixed_512 on Recall@5 and beats it on MRR. The earlier “sweet spot at 512” was substantially the model’s window in disguise.</p><p><strong>And the semantic verdict, now on a level field:</strong> semantic chunking recovered most where truncation had hurt it most (+11 points of Recall@10), which confirms how much the blindfold cost. But it is <em>still</em> last on every metric. With its chunks fully visible, the remaining deficit is the real dilution effect: fewer, larger chunks genuinely do retrieve worse than structure-aware moderate ones. Truncation was about half the story; dilution is the other half.</p><p>I found it interesting that the chunking ranking (structure-aware on top, semantic at the bottom) held under both models.</p><h3>While we are reading model cards</h3><p>The window is not the only contract hidden in an embedding model’s card. Some models require task prefixes: nomic-embed-text, an 8k-window model, degrades measurably unless every query starts with search_query: and every document with search_document:. BGE recommends (but does not require) a query instruction we did not use here. Context windows, prefixes, normalisation: each unread line of the model card is a silent few points of recall.</p><p>If you need bigger windows, they exist at every scale: nomic-embed-text and gte at 8k tokens locally, Qwen3-Embedding at 32k, and hosted options from OpenAI (8k), Voyage (32k), and Cohere (128k). Since we’re running 100% local, we used Qwen3. A big window buys safety, but you still need to chunk the inputs. A single vector still has to summarise whatever you put in it, and the dilution result holds no matter how much fits.</p><h3>Does a bigger model help? (bge-large)</h3><p>bge-small fixed the window problem, but it is still a 33-million-parameter model, the same weight class as MiniLM. The next lever is capacity. bge-large-en-v1.5 is the same model family with the same 512-token window and roughly ten times the parameters, which made it the cleanest possible test. Only the model size changes, everything else stays constant. As before, the swap is a re-embed, and a re-run. No FileMaker code changes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/950/1*3t9M_tDA10tW1LeiqDErVw.png" /></figure><p>The parameter jump is worth about seven points across the board over bge-small, comfortably beyond noise. But the striking row is the second one: structural chunking on bge-large <em>without</em> a reranker (Recall@5 0.740, MRR 0.592) essentially matches structural on bge-small <em>with</em> the reranker (0.732, 0.641). A bigger embedding model buys you most of what the rerank stage bought. And the two still stack: adding the reranker on top is worth another twelve points of Recall@1, for a new best of 0.602.</p><h3>An effectively infinite window (Qwen3)</h3><p>There’s still another question remaining. On paper, bge’s 512-token window fits every chunk in every config, including semantic’s largest. But “on paper” is exactly what caused the truncation problem earlier, and semantic’s biggest chunks sit close enough to the limit to leave doubt. So, I made one final swap, to use Qwen3-Embedding-0.6B, a 600-million-parameter model with a 32,768-token window. Our largest chunk is about 500 tokens. Nothing can possibly truncate; there is two orders of magnitude of headroom. This settles two questions at once: is the dilution verdict against semantic chunking real, and does a bigger window itself buy anything once your chunks actually fit?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/898/1*dHnONrJgSgn9TV760Rpe0g.png" /></figure><p><strong>Dilution is happening.</strong> With a 32k window and zero truncation, semantic chunking still finishes last, sixteen points of Recall@1 behind structural on the same model. Its trajectory across the three eras tells the whole story: Recall@1 of 0.285 blindfolded under MiniLM, 0.333 under bge-small, 0.407 with every character visible under Qwen. Fixing truncation helped it most of any config, and it still never got close. Fewer, larger, topically coherent chunks genuinely retrieve worse: a single vector asked to summarise more ideas summarises each of them less well.</p><p><strong>And the window itself bought nothing.</strong> Qwen’s raw retrieval is stronger than bge-large’s (0.504 versus 0.431 Recall@1 on the naive config), but after the reranker the two big models converge to a statistical tie: 0.610 versus 0.602 Recall@1, with bge-large actually ahead on Recall@5 and essay recall. Once your chunks fit inside the window, extra window is headroom you are not using. Between these two finalists, bge-large is the practical pick: a fraction of the size, several times faster, and no memory drama.</p><p>One more result to consider. The chunking ranking (structure-aware on top, semantic at the bottom) has now held across four embedding models spanning a 20x parameter range and a 256x window range.</p><h3>The final pipeline</h3><p>This table shows every improvement, stacked on the last:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s_JQ7Xj3LO1OZz-d_Oh1Dg.png" /></figure><p>The right passage is now the first result 60% of the time instead of 33%, in the top five 79% of the time instead of 58%, and the right essay is in the top five 85% of the time. The reranker was the single biggest lever, the embedding model was worth nearly as much and chunking set the ceiling for both. Perhaps surprisingly a 64x bigger context window didn’t make a significant improvement, but it was much slower to run. Every stage runs locally: FileMaker performing the search, a local embedding model, a local reranker, and not a byte of your data leaving the building.</p><p>Here are a few caveats: 123 questions means differences under about 4 points are noise (the big effects here, reranking, the model swap, and the truncation cliff, are far outside it). The question set is synthetic, generated and filtered by LLMs, and inherits their tastes. Every number is specific to this corpus and these models. Which is really the main point of this post: run the measurement on your own data, audit the constraints of your own pipeline, and only then trust a conclusion, whether it comes from a blog post or from your own first results table.</p><h3>Doing this on your own data</h3><p>Everything above is reproducible with modest effort: a small FastAPI server for chunking, embeddings, and reranking, five FileMaker scripts, and two Python scripts for question generation and scoring. FileMaker’s native AI script steps handle the search itself, and the whole pipeline runs locally, which matters if your data cannot leave the building.</p><p>It is also exactly the kind of plumbing we have been building into products: an intelligent chunking and embedding engine, and a local high-performance search server with hybrid retrieval and reranking built in, both as single-file executables that pair with FileMaker. If you would rather start from working tools than build the pipeline yourself, or if there is a semantic search project you are interested in but you are unsure where to start, <a href="/service/mailto:hello@transformingdigital.ai">get in touch</a>. I would love to discuss it.</p><p><em>I write a weekly newsletter on putting AI into real business systems, mostly FileMaker, mostly running locally. Free, and I write it myself: </em><a href="https://ianjempson.substack.com/subscribe"><em>subscribe</em></a><em> at ianjempson.substack.com.</em></p><p><em>Sources and further reading: Chroma’s </em><a href="https://www.trychroma.com/research/evaluating-chunking"><em>Evaluating Chunking Strategies for Retrieval</em></a><em> (Smith &amp; Troynikov), Greg Kamradt’s </em><a href="https://github.com/FullStackRetrieval-com/RetrievalTutorials/blob/main/tutorials/LevelsOfTextSplitting/5_Levels_Of_Text_Splitting.ipynb"><em>5 Levels of Text Splitting</em></a><em>, Antematter’s </em><a href="https://antematter.io/blogs/optimizing-rag-advanced-chunking-techniques-study"><em>chunking study</em></a><em> on the same corpus, and the </em><a href="https://agentset.ai/rerankers"><em>Agentset reranker leaderboard</em></a><em>. The Paul Graham essay dataset is </em><a href="https://huggingface.co/datasets/sgoel9/paul_graham_essays"><em>sgoel9/paul_graham_essays</em></a><em> on Hugging Face.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=59d4f8a50f49" width="1" height="1" alt=""><hr><p><a href="https://medium.com/transforming-digital/your-filemaker-semantic-search-is-fast-is-it-right-59d4f8a50f49">Your FileMaker Semantic Search Is Fast. Is It Right?</a> was originally published in <a href="https://medium.com/transforming-digital">Transforming Digital</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Isn't the Machine. It's the Kaizen System.]]></title>
            <link>https://medium.com/transforming-digital/ai-isnt-the-machine-it-s-the-kaizen-system-d82751026950?source=rss----ae52702e0e12---4</link>
            <guid isPermaLink="false">https://medium.com/p/d82751026950</guid>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[kaizen]]></category>
            <category><![CDATA[startupş]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[productivity]]></category>
            <dc:creator><![CDATA[Ian Jempson]]></dc:creator>
            <pubDate>Tue, 09 Jun 2026 09:15:48 GMT</pubDate>
            <atom:updated>2026-07-13T12:07:21.866Z</atom:updated>
            <content:encoded><![CDATA[<h3>Stop Buying AI. Start Running Kaizen With It.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LOpvM2s7jDIpT--_t_FuwA.png" /></figure><p>Most firms adopt AI the way a factory buys a faster machine. They install it on one production line, measure the output gain, and move on. A year later the machine is running at capacity, the gains have plateaued, and nobody has asked how the rest of the factory should change around it.</p><p>Toyota would recognise the mistake. It’s the same one Western manufacturers made for decades: treating improvement as a project with a start and an end, rather than a habit that never stops. The genius of the Toyota Production System was never a single clever machine. It was Kaizen — 改善, “change for the better” — the discipline of small, continuous, everyone-participates improvement, run as a permanent loop rather than a one-off event.</p><p>Most organisations see AI as the machine. The more interesting possibility is that it becomes the Kaizen system. A large language model doesn’t just perform work faster; it can observe work, capture knowledge, identify friction, suggest improvements, and help implement them. In other words, it can participate in the improvement loop itself.</p><p>That’s the opportunity most firms are missing: AI is not merely another target for optimisation. It can become the engine that keeps optimisation running.</p><h3>What Kaizen actually is</h3><p>Strip away the management-consultant gloss and Kaizen is almost embarrassingly simple. You go and look at how work really happens — Toyota calls this <em>gemba</em>, “the actual place.” You find a small piece of waste or friction. You form a hypothesis about a better way. You try it on a small scale, measure the result, and either keep the change or discard it. Then you do it again tomorrow.</p><p>That’s the Plan-Do-Check-Act cycle. The magic isn’t in any single turn of the wheel; it’s in the compounding. A one-percent improvement, repeated and sustained, eventually outruns almost any heroic transformation programme. The transformation happens once. Kaizen happens every day.</p><p>Toyota’s advantage was never that it invested more than its rivals. It was that it learned faster. It found improvements, tested them, and embedded them into the way work was done — again and again, year after year.</p><p>The reason most organisations struggle to sustain this discipline has always been economic. Going to gemba, spotting waste, documenting a better way, measuring whether it worked, and ensuring the change sticks all require human effort. That effort competes with the work itself.</p><p>The loop is easy to explain but expensive to run. Sooner or later the measurements stop, the experiments become less frequent, and improvement turns back into a periodic project. This is exactly where the economics have just changed.</p><h3>The model as the loop, not the lever</h3><p>The instinctive way to combine AI and continuous improvement is to use the model as a faster lever. It writes the email faster, summarises the report faster, drafts the code faster. Useful, certainly. But you’re still running the improvement loop yourself and occasionally reaching for a more powerful tool.</p><p>The more interesting possibility is to hand the model parts of the loop itself.</p><p><strong>Going to gemba.</strong> An LLM can read across the artefacts your process actually produces: support tickets, meeting notes, pull requests, handover documents, and the Slack thread where the same question gets asked for the fourth time. From that process exhaust it can surface recurring delays, bottlenecks, and sources of rework. It cannot replace a leader observing work firsthand. It can, however, do something no human can: hold an entire month’s worth of operational detail in view at once and identify patterns that would otherwise remain invisible.</p><p><strong>Maintaining standard work.</strong> In Toyota, every improvement becomes the new current-best-known way of doing the job. Standard work is not bureaucracy; it is the baseline that the next improvement must beat. Yet documentation is usually the first casualty of a busy organisation because maintaining it is tedious. This is exactly the sort of task language models excel at. They can observe how work is performed, draft the standard, and continuously update it as the process evolves. The thing that always decayed becomes cheap to maintain.</p><p><strong>Proposing the next experiment.</strong> Once friction has been identified and the current standard is understood, the model can suggest the next small, testable change. Not a mandate. A hypothesis. Humans still decide what matters and which trade-offs to make. Humans still run the experiment. But the cost of answering the question, “What should we try next?” falls dramatically. The loop keeps moving instead of stalling.</p><p>Notice what’s changed. In none of these examples does AI primarily make the existing process faster. Its value comes from lowering the cost of improving the process itself. And that was always the scarce resource in Kaizen.</p><h3>A concrete example</h3><p>This stays abstract until you’ve watched it run, so here’s one from my own company.</p><p>I build software products, and every product needs a folder structure: where the specifications live, where the assets go, what everything is named, and how work is organised. For years I did this by hand, and the result was exactly what you’d expect. Every product was slightly different. Nobody was entirely sure where to look for things. Small frictions accumulated everywhere. Pure muda.</p><p>So I wrote the structure down as standard work — except the document isn’t a document. It’s a Claude skill.</p><p>Now, whenever I start a new product, the structure is created the same way every time: same folders, same names, same place for everything. The inconsistency waste disappeared.</p><p>But that isn’t the Kaizen part.</p><p>The Kaizen part came afterwards. As we worked, we kept discovering small improvements: a folder that belonged somewhere else, a naming convention that scaled better, a missing category that would save time later. Each time, we changed the structure and updated the skill.</p><p>The skill became the living record of our current best-known way to do the job.</p><p>And because the skill lives in version control, we have something Toyota’s engineers could only dream of: a complete, timestamped history of how our standard work evolved. Every improvement is recorded. Every change has a rationale. Every iteration becomes part of the organisation’s memory.</p><p>This is what makes AI different from traditional documentation. The standard work doesn’t sit in a binder waiting for someone to follow it. It executes itself.</p><p>The moment a better way is discovered, the capability itself can be updated. The next project automatically benefits from everything learned on the previous one.</p><p>That is the entire Kaizen loop in miniature. We noticed friction in real work (gemba). We changed the standard. The next project became the experiment. The results informed the next version. Then we did it again.</p><p>The folder structure is trivial but the pattern is not.</p><h3>Why this is a founder’s problem, not the IT department’s</h3><p>It’s tempting to file this under operations and move on. Don’t. Three reasons it belongs on the founder’s desk.</p><p>First, compounding is a strategic asset and it’s invisible on any single day. One percent better this week looks like nothing; sustained for two years it’s a different company. Only leadership can protect a practice whose payoff is always over the horizon — the quarterly mindset kills it every time.</p><p>Second, the moat is the loop, not the tool. Your competitors can buy the same models you can. What they can’t trivially copy is an organisation that has spent a year getting good at improving itself with those models. The advantage isn’t the AI; it’s the accumulated rate of learning around it.</p><p>Third, Kaizen is cultural before it’s technical. Toyota’s system runs on respect for people. Improvements come from the people doing the work, not imposed on them. Bolt AI on as a surveillance-and-automation play and you’ll get the waste Toyota spent decades eliminating: fear, gaming, and a workforce that hides problems instead of surfacing them. Frame it as giving every person a tireless partner for spotting and fixing friction, and you get the opposite. Either set that framing at the top or not at all.</p><p>Which leads to the final responsibility of leadership: protecting the discipline itself.</p><h3>The discipline it doesn’t remove</h3><p>A fair warning, because AI introduces a new failure mode. The model is perfectly capable of generating an endless stream of suggestions, observations and potential improvements. But an endless stream of improvements is itself a form of waste — Toyota would call it overproduction.</p><p>The purpose of Kaizen was never to maximise the number of ideas. It was to maximise the number of useful improvements that were tested, measured and retained.</p><p>That’s why the human parts remain stubbornly human. Someone still decides which experiment is worth running. Someone still owns the measurement that says whether it worked. Someone still has the judgement to reject a change that sounded plausible but made things worse.</p><p>The model can help run the loop. It doesn’t get to close it. In fact, the more capable the models become, the more valuable that discipline becomes. When generating ideas is almost free, selecting the right ones becomes the scarce resource.</p><p>Toyota’s lesson was never “improve everything.” It was “improve deliberately, learn from the result, and make the learning stick.”</p><p>AI changes the economics of the loop but It doesn’t change the need for judgement.</p><h3>Where to start</h3><p>Pick one process you actually own — onboarding a customer, closing the monthly books, triaging inbound, shipping a release. Not the whole company. One loop. Point the model at a month of that process’s real artefacts and ask it where the friction is. Pick the single smallest improvement worth trying. Run it. Measure it. Keep it or kill it. Then do it again next week.</p><p>That’s it. That’s the whole strategy. Toyota built one of the most valuable companies on earth out of repeating that sentence for fifty years — and you now have an engine that makes each turn of it cheaper than it has ever been.</p><p>Most organisations are using AI as a faster machine. The bigger opportunity is to use it as the system that keeps improving the machine.</p><p>The firms that win the next few years won’t be the ones with the best AI.</p><p>They’ll be the ones that got best at improving themselves with it.</p><p><em>I write a weekly newsletter on putting AI into real business systems, mostly FileMaker, mostly running locally. Free, and I write it myself: </em><a href="https://ianjempson.substack.com/subscribe"><em>subscribe</em></a><em> at ianjempson.substack.com.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d82751026950" width="1" height="1" alt=""><hr><p><a href="https://medium.com/transforming-digital/ai-isnt-the-machine-it-s-the-kaizen-system-d82751026950">AI Isn&#39;t the Machine. It&#39;s the Kaizen System.</a> was originally published in <a href="https://medium.com/transforming-digital">Transforming Digital</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Coding FileMaker with LLMs: my current thinking]]></title>
            <link>https://medium.com/transforming-digital/coding-filemaker-with-llms-my-current-thinking-c6c0400fcac0?source=rss----ae52702e0e12---4</link>
            <guid isPermaLink="false">https://medium.com/p/c6c0400fcac0</guid>
            <category><![CDATA[filemaker]]></category>
            <category><![CDATA[ai-coding]]></category>
            <category><![CDATA[claris]]></category>
            <category><![CDATA[claude-code]]></category>
            <dc:creator><![CDATA[Ian Jempson]]></dc:creator>
            <pubDate>Fri, 15 May 2026 10:35:25 GMT</pubDate>
            <atom:updated>2026-07-13T12:08:09.994Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*snBfYEnkg76PFzUJTO0YUw.png" /></figure><p>Given the immense pace of change, I’m sure this will be out of date soon. So this is as of May 2026.</p><p>It’s an area I’ve been thinking about for a while and I seriously considered building a product in this space around four to six months ago. I didn’t proceed, for a few reasons: the market, the underlying technology moving fast, and a feeling that getting to 90% would be relatively straightforward but the remaining 10% would be tremendously difficult.</p><h3>The four current integration methods</h3><p>Before listing them, one clarification. “AI in FileMaker” splits into two quite different things: developers using AI to build apps, and end users interacting with AI inside finished apps. This piece is about the first. The user-facing side is its own topic and worth a separate conversation.</p><p>For developers, there are roughly four techniques in play today. Two of them are general-purpose transports that can move almost anything (scripts, calcs, schema, layouts) from an LLM into a FileMaker file. The other two are more specific: one addresses the data and schema layer of a hosted file, and one is about how the interface itself gets built and rendered.</p><h4>General-purpose transports</h4><p><strong>1. The FileMaker clipboard format (FM XML snippet).</strong> You write code in Claude, Gemini or whichever LLM, get it into FM XML snippet format, then paste it into FileMaker. The flow also works in reverse: copy a script or script step out of FileMaker, paste into Claude, have it rewrite or convert, then paste back. This works well at the individual script level, but it won’t scale. The friction is the copy-paste loop and a few technical edges I won’t get into here. I demoed this on Matt Navarre’s <a href="https://youtu.be/w3DmUqUjdSw?t=1812">podcast</a> a while ago. I focused on scripts and schema rather than layouts. It’s worth mentioning that Claude can also do an extremely good job of critiquing a script.</p><p><strong>2. The FMUpgradeTool.</strong> This takes correctly formatted XML and applies it to a FileMaker file, upgrading it. So you can write in Claude and use the Upgrade Tool to push changes back into the system. The promising part is that it gets you table occurrences and relationships, which have historically been the hard bit. However, it requires a closed local file, meaning you’ll need to think seriously about the devops pipeline.</p><h4>Live data and schema</h4><p><strong>3. OData.</strong> OData lets you create or modify the schema of a hosted FileMaker database, and it’s standard enough that LLMs handle it natively. So Claude can modify the schema of a hosted file and that works pretty well.</p><h4>Interface</h4><p><strong>4. HTML in a web viewer.</strong> This technique works beautifully. You use the LLM to write HTML and JavaScript, render it inside a web viewer, and run a standardised set of scripts to bridge the web viewer and FileMaker data and scripts. You can build beautiful interfaces this way, the tooling is standardised, and it fits naturally with Git. Developers are already delivering AI generated client work this way.</p><h3>The gap</h3><p>FileMaker is a monolithic system and changes need to be coordinated across all aspects of an app. Getting the schema right and the interface correct means the scripting also needs to be right. Getting the many linked dependencies updated in the right order in the complex underlying XML is a non-trivial problem.</p><p>We don’t have a single joined-up method covering all of this, and that’s where things get messy. <a href="https://www.claris.com/blog/2026/how-claris-is-building-for-what-comes-next">Ryan McCann’s (CEO of Claris) blog post </a>was good and showed Claris understands the direction they need to go in, which is the most important thing. But tying these pieces together is going to be tricky. For now I think we have to mix and match.</p><p>A few products are emerging in this space. When I assessed it, my conclusion was that building something with commercial-grade polish would be tremendously difficult, partly because things are moving fast and partly because Claris is going to do this themselves. As I said before, getting to 90% is easy. That last 10% will be hard.</p><h3>What I’m actually doing</h3><p>A concrete example. I’ve built a product alongside FileMaker that handles <a href="https://transformingdigital.ai/transcribr/">transcription</a>, and the demo file has a lot of integration endpoints. The Insert from URL script shows up a lot and I got tired of writing essentially the same boilerplate again and again with slightly different parameters and endpoints. So I copied the script, pasted it into Claude, described what I wanted, gave Claude access to the FileMaker documentation, and had it rewrite the script. Within a couple of iterations it was producing a well-commented, clearly structured script with detailed error handling. It also flags up areas where developer input or decisions are required.</p><p>I wrote a Python script to convert to and from the clipboard format, which everyone going down this road has done as well. The Claude skill knows when and how to use that script. Then I pointed Claude at the Swagger endpoints for the API and it generated the full set of scripts. I pasted them into FileMaker and they worked first time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bwPy9esO5rL6VQPCNYu0Ew.png" /></figure><p>The key here was a really narrow focus. I wasn’t trying to solve every problem, just one specific recurring one.</p><h3>What to automate, what to leave alone</h3><p>I think a lot of people are getting this wrong with LLMs by trying to automate everything. You shouldn’t. Think carefully about where the value is, where the process is repeatable, and where an LLM can genuinely help.</p><ul><li><strong>Worth automating:</strong> my Insert from URL pattern is a generalised skill, integrating with Swagger-described APIs, which I do a fair bit. Generating database schema is also worth it. On <a href="https://youtu.be/w3DmUqUjdSw?t=3433">Matt’s podcast</a> I asked Claude to research a reference schema (the example was oil companies), generate the schema, and convert it to the Upgrade Tool’s XML format. That saved real time.</li><li><strong>Worth being realistic about:</strong> FileMaker is fairly unique in how it uses table occurrence groups, so what you get out of generic schema generation is a more standard ERD, not an Anchor-Buoy layout. You could prompt your way there but it’s a lot of work and I’m not sure it makes sense to automate.</li><li><strong>Not worth automating right now:</strong> value lists, fiddly UI work. For me the effort to build a repeatable process outweighs the payoff at current volumes.</li></ul><p>For UI, my feeling is the web viewer approach is probably the best bet. The native FileMaker layout XML has a lot of complexity and fiddly bits, and that’s exactly the area where Claris is going to add real value with what they’re building.</p><h3>Tokens, plans, and local models</h3><p>A practical note. OpenAI and Anthropic are effectively subsidising us on token usage right now, and working on this stuff burns through tokens fast. Realistically you want to be on a monthly plan, the $100 or $200 tier, although you can get reasonably far on the smaller plans with more careful planning. Doing this metered would get expensive.</p><p>I don’t think the cost of tokens is the real issue. The real issue is that this is still very much a learning phase and you’ll burn a lot of tokens learning. You don’t want to be doing your learning on a meter.</p><p>On local models: yes you can run them locally, but realistically you need a fairly hefty model. A 32GB machine isn’t going to run a coding model strong enough for FileMaker work. Even frontier models weren’t really useful for FileMaker until around mid-December 2025 when Opus 4.5 came out. That was a big step change.</p><h3>Summing up</h3><p>If you’re not playing around with coding FileMaker using an LLM yet, you probably should be. My guidance:</p><ul><li>Keep the focus narrow. Pick repeatable, high-friction problems.</li><li>For UI work, lean toward the web viewer plus HTML route.</li><li>For schema, OData is fine for updates on a hosted file, but version-control your schema and track your changes.</li><li>For scripts, the clipboard round-trip works well at the individual level. But it won’t scale.</li><li>LLMs are excellent script reviewers, even when you write the code yourself.</li><li>For everything else around the edges of FileMaker, not much yet. I’m looking forward to seeing what Claris ships.</li></ul><p>I’d rather use a general-purpose tool with some skills around it right now than commit to an external product, because the landscape will shift quite a bit over the next year.</p><p><em>I write a weekly newsletter on putting AI into real business systems, mostly FileMaker, mostly running locally. Free, and I write it myself: </em><a href="https://ianjempson.substack.com/subscribe"><em>subscribe</em></a><em> at ianjempson.substack.com.</em></p><p>Note: <a href="https://danielmiessler.com/blog/ai-influence-level-ail"><em>AIL 1</em></a><em> (human-written, AI-assisted proofreading and minor edits).</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c6c0400fcac0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/transforming-digital/coding-filemaker-with-llms-my-current-thinking-c6c0400fcac0">Coding FileMaker with LLMs: my current thinking</a> was originally published in <a href="https://medium.com/transforming-digital">Transforming Digital</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What the LiteLLM Attack Taught Us: Hardening Our Python Supply Chain Before a Product Release]]></title>
            <link>https://medium.com/transforming-digital/what-the-litellm-attack-taught-us-hardening-our-python-supply-chain-before-a-product-release-388505d8c5c5?source=rss----ae52702e0e12---4</link>
            <guid isPermaLink="false">https://medium.com/p/388505d8c5c5</guid>
            <category><![CDATA[security]]></category>
            <category><![CDATA[software-supply-chain]]></category>
            <dc:creator><![CDATA[Ian Jempson]]></dc:creator>
            <pubDate>Mon, 30 Mar 2026 11:22:56 GMT</pubDate>
            <atom:updated>2026-07-13T12:10:16.878Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PG0IybGj0rIk0vIDvwnB9g.png" /></figure><p>On 24 March 2026, a threat actor group called TeamPCP uploaded two malicious versions of LiteLLM to PyPI.</p><p>LiteLLM is a unified Python interface for calling LLM APIs — OpenAI, Anthropic, Google, and dozens of others. It has roughly 3.4 million downloads per day and, according to Wiz, is present in 36% of cloud environments.</p><p>The compromised versions (1.82.7 and 1.82.8) were live on PyPI for approximately three hours.</p><p>Inside them was a multi-stage credential stealer that harvested:</p><ul><li>SSH keys</li><li>Cloud credentials</li><li>Kubernetes tokens</li><li>Database passwords</li><li>TLS private keys</li><li>Cryptocurrency wallets</li></ul><p>The particularly nasty part: version 1.82.8 installed a .pth file into the Python environment.</p><p>Python processes .pth files automatically on startup, which meant the malicious code ran on <em>every Python invocation</em> on the affected machine — even if you never imported LiteLLM.</p><p><strong>Three hours. That’s all it took.</strong></p><p>We weren’t affected by this particular attack as we don’t use LiteLLM in our products. But we were days away from a product release when it happened, and it stopped us in our tracks.</p><p>Not because of any immediate risk, but because it forced a question we hadn’t asked thoroughly enough:</p><p><strong>How confident are we in our own supply chain?</strong></p><p>The honest answer was: not confident enough.</p><p>Not all of our products use Python, but enough of our tooling does that the question applied. The LiteLLM attack forced us to look at our supply chain practices more broadly — especially in the parts of our stack that do rely on Python.</p><p>In those projects, we were using pip with pinned versions. That felt responsible — but as we’ll explain, it doesn’t actually verify enough.</p><h3>The Problem with pip</h3><p>Most Python developers manage dependencies with pip and a requirements.txt file. You pin your versions — litellm==1.82.6 — and call it done.</p><p>This is better than nothing, but it creates a false sense of security.</p><h4>Version pinning doesn’t verify content</h4><p>When you pin litellm==1.82.6, pip checks that the version number matches. It does not verify that the <em>contents</em> of the package are what you expect.</p><p>If you install during a window where a malicious version is published, or a maintainer account is compromised and a new version is pushed, pip will happily install it.</p><p>The version number is a label, not a seal.</p><h4>pip executes arbitrary code during installation</h4><p>Source distributions (sdists) require running setup.py to build. That’s arbitrary Python code execution triggered by pip install. You are running untrusted code as a side effect of installing a package.</p><p>The LiteLLM attack used a different mechanism (a .pth file), but the principle is the same: there are too many places where code runs implicitly.</p><h4>pip’s default index behaviour creates confusion risk.</h4><p>If you use a private package index alongside PyPI, pip by default queries all configured indexes and picks the best version match. This opens the door to dependency confusion attacks — an attacker publishes a same-named package on PyPI with a higher version number, and pip prefers it. Recent<br> versions of pip offer — index-strategy to control this, but the default behaviour remains permissive, and many teams don’t change it.</p><h4>Transitive dependencies are invisible</h4><p>Your requirements.txt might pin 10 packages. Those 10 depend on another 50, which depend on another 150.</p><p>You’ve audited none of them and a compromise anywhere in that tree reaches your application.</p><figure><img alt="A simple tree diagram for transitive dependencies. It has “Your app” on the top layer, which has direct dependencies attached to it on the second layer. Transitive dependencies are on the third layer, which are attached to the second layer, and deep dependencies (labeled with the word “risk”) are on the bottom layer, attached to the layer above." src="https://cdn-images-1.medium.com/max/1024/1*10G0u-Qwlv-ULcTwYPPFfg.png" /></figure><p>None of this is really pip’s fault. It was designed before supply chain attacks were a primary concern.</p><p>But the threat model has changed. The tooling needs to change with it.</p><h3>Moving to uv</h3><p>uv is a Python package manager written in Rust by Astral (the team behind Ruff).</p><p>It’s best known for being fast — often 10–100x faster than pip. But the security properties are what made us switch.</p><h4>Hash-verified lockfiles</h4><p>uv.lock pins every dependency — including transitive dependencies — with both an exact version and a SHA-256 hash of the package contents.</p><p>When you run uv sync, it verifies the hash of every downloaded package against the lockfile. If the content has changed, the install fails.</p><p>This is the single most important difference from pip.</p><h4>The --no-build flag</h4><p>Running: uv pip install --no-build refuses to build any source distributions.</p><p>Wheels can still contain malicious code that executes at import or runtime so this isn’t a complete defence, but it removes one of the most dangerous attack surfaces: arbitrary code running before you’ve even used the package.</p><p>If a wheel isn’t available, the install fails instead of silently falling back to building from source.</p><h4>The --exclude-newer cooldown</h4><p>Running: uv lock --exclude-newer &quot;7 days&quot;tells uv to ignore any package version published within the last seven days.</p><p>Most supply chain attacks are detected within hours or days. The LiteLLM malicious versions were live for just three hours. A seven-day cooldown would have blocked the attack completely.</p><h4>First-index-wins resolution</h4><p>When multiple package indexes are configured, uv selects from the first index that has the package and stops. It does not search for a “better” match elsewhere.</p><p>This prevents dependency confusion attacks by design.</p><h4>Minimal Python execution</h4><p>uv parses package metadata natively in Rust wherever possible. It only invokes Python when absolutely necessary (e.g. legacy setup.py-only packages).</p><p>Less Python execution during dependency resolution means fewer opportunities for malicious code to run.</p><h4>Trade-offs</h4><p>uv is still relatively new, and not every tool in the Python ecosystem integrates cleanly with it yet. In our case the migration was painless — but your mileage may vary depending on your stack. For us the security benefits made it an easy call.</p><p>The following summarises the key points.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4p98x-88IeKEyTlx--cVyA.png" /></figure><h3>Scanning at Every Stage of Development Process</h3><p>Hardening installs is necessary, but not sufficient. Dependencies are a moving target. Vulnerabilities are disclosed after you’ve already installed a package.</p><p>Security has to be continuous. To that end we’re scanning at every stage of the development process.</p><h4>On dependency change</h4><p>Any edit to pyproject.toml or uv.lock triggers a vulnerability scan against <em>osv-scanner</em> run against the <a href="https://osv.dev/">OSV</a> vulnerability database. This catches issues at the moment they’re introduced</p><h4>On every commit</h4><p>We added a pre-commit hook that audits the full dependency tree — including transitive dependencies.</p><p>If a known vulnerability exists anywhere in the tree, the commit is blocked.</p><h4>During development</h4><p>Claude Code is part of our workflow and we hook into dependency file changes to trigger scans during development.</p><p>This catches issues before they even reach the commit stage.</p><p>The uncomfortable truth is transitive dependencies are the hidden risk. Your direct dependencies may be well-maintained. Their dependencies may not be. If an attack lands four levels deep, you’re still affected.</p><h3>Why This Matters Now</h3><p>This isn’t theoretical for us.</p><p>We’re preparing to release AI tools that run on our customers’ machines — fully local, no cloud calls, no data leaving the device.</p><p>That’s our core value proposition, especially for customers in financial services. A supply chain compromise would directly undermine that.</p><p>If a malicious dependency is bundled into our product, it runs with our permissions on the customer’s machine.</p><p><strong>Your dependency chain is part of your product.</strong></p><p>Your users don’t distinguish between code you wrote and code you shipped.</p><p>In practice, neither can you.</p><h3>What You Can Do Today</h3><p>If you’re shipping Python-based software:</p><ol><li><strong>Use hash-verified lockfiles</strong><br>uv, pip-tools with --generate-hashes, or Poetry — just don’t rely on versions alone.</li><li><strong>Add a dependency cooldown window</strong><br>A 7-day delay blocks most real-world supply chain attacks.</li><li><strong>Scan continuously</strong><br>Not just once. Every commit. The full dependency tree.</li><li><strong>Understand your transitive dependencies</strong><br>If you don’t know what’s 3–4 levels deep, you have unexamined risk.</li><li><strong>Treat dependencies as attack surface</strong><br>Every package is a trust decision you’re making on behalf of your users.</li></ol><p>The LiteLLM attack lasted three hours.</p><p>Three hours is all it takes.</p><p>Assume it will happen again — and make sure your tooling is built for that reality.</p><p><em>I write a weekly newsletter on putting AI into real business systems, mostly FileMaker, mostly running locally. Free, and I write it myself: </em><a href="https://ianjempson.substack.com/subscribe"><em>subscribe</em></a><em> at ianjempson.substack.com.</em></p><p><em>At </em><a href="https://transformingdigital.ai/"><em>Transforming Digital</em></a><em>, we build AI tools designed for local execution in security-conscious environments. Supply chain security isn’t a feature we bolt on — it’s built into how we develop and ship software. If you’re navigating similar challenges, </em><a href="http://hello@transformingdigital.ai/"><em>we’d like to hear from you</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=388505d8c5c5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/transforming-digital/what-the-litellm-attack-taught-us-hardening-our-python-supply-chain-before-a-product-release-388505d8c5c5">What the LiteLLM Attack Taught Us: Hardening Our Python Supply Chain Before a Product Release</a> was originally published in <a href="https://medium.com/transforming-digital">Transforming Digital</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Using Apple Foundation Models in FileMaker]]></title>
            <link>https://medium.com/transforming-digital/using-apple-foundation-models-in-filemaker-ba25d6c80739?source=rss----ae52702e0e12---4</link>
            <guid isPermaLink="false">https://medium.com/p/ba25d6c80739</guid>
            <dc:creator><![CDATA[Ian Jempson]]></dc:creator>
            <pubDate>Fri, 31 Oct 2025 08:49:50 GMT</pubDate>
            <atom:updated>2026-07-13T12:11:15.623Z</atom:updated>
            <content:encoded><![CDATA[<p>On September 15, 2025 Apple released the Tahoe edition of the Mac OS. This upgrade includes onboard AI models, referred to as Apple Foundation Models. These models allow us to use AI models locally. They’re designed to be small and fast when running on consumer grade hardware.</p><p>In other words, they’re ideal for use with FileMaker solutions. There is no requirement to connect to a server or manage models yourself. If you’ve got the requirements in place it’s a matter of a few script steps to take advantage of the new capabilities.</p><p>The current FileMaker version as I write this (October 2025) doesn’t have script steps or functions to use Foundation Models. Claris was planning this and it’s on the road-map, however Apple was slower at delivering the models than expected. So for the moment we’ll need to use a plugin, but it will come to FileMaker natively before long. As is so often the case with FileMaker MonkeyBread Software has stepped in with the MBS plugin to provide the missing feature. Foundation Model support is included from version 15.5, which is in beta as I write this.</p><p>FileMaker’s current LLM functions work with providers using the OpenAI standard API format. It’s a bit picky about this and doesn’t work with all models or providers. The simplest alternative thus far for on-device inference has been to use Ollama for hosting the models and using Insert from URL to communicate with it. For an experienced developer this is relatively straightforward and provides good performance with more flexibility than using FileMaker Server’s AI hosting capabilities.</p><h3>In Action</h3><p>Here’s a short video of the script in action running on my M1 MacBook Pro. It’s got only 16GB so it shows a good example of running in a limited environment.</p><p>Performance-wise, a query to create a recipe from limited ingredients is taking about 8 seconds on average. Bear in mind, that’s while recording a video on a not so powerful laptop.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fplayer.vimeo.com%2Fvideo%2F1132435512%3Fapp_id%3D122963&amp;dntp=1&amp;display_name=Vimeo&amp;url=https%3A%2F%2Fvimeo.com%2F1132435512&amp;image=https%3A%2F%2Fi.vimeocdn.com%2Fvideo%2F2076661422-8f2dd0768eef191b9a5126ab71d004dd80408f0c2a47b00f21ad60f02b908716-d_1280%3Fregion%3Dus&amp;type=text%2Fhtml&amp;schema=vimeo" width="1920" height="1212" frameborder="0" scrolling="no"><a href="https://medium.com/media/5f55a766ca0a8916c83c39f7b748ceae/href">https://medium.com/media/5f55a766ca0a8916c83c39f7b748ceae/href</a></iframe><h3>The Script</h3><p>So what does the script look like? It’s pretty simple:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OiUEpOvXzuGwjRMQNPpRLA.png" /></figure><h3>Why?</h3><p>Using local models can prove more responsive while providing better security for your data. The downside of Foundation Models is that they have a limited context window, 4096 tokens. This is quite small, but larger context windows will require much more beefy models which in turn means more RAM.</p><p>This can run in a compiled version of FileMaker Go. Building such a compiled app is more of an undertaking, but if you’ve got mobile users think how useful it could be for them to have LLM inference on the go.</p><p>My go-to approach so far has been to use Ollama locally. This allows for a wider selection of models and I generally use the Gemma series which are great for structured data and tool calling.</p><p>So, while not perfect, it provides us with another tool we can use to implement local intelligence. I look forward to the FileMaker native implementation!</p><p>If you need help with FileMaker AI integration feel free to reach out. I provide services ranging from AI strategy, through mentoring and training, as well as system design and implementation.</p><p><em>I write a weekly newsletter on putting AI into real business systems, mostly FileMaker, mostly running locally. Free, and I write it myself: </em><a href="https://ianjempson.substack.com/subscribe"><em>subscribe</em></a><em> at ianjempson.substack.com.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ba25d6c80739" width="1" height="1" alt=""><hr><p><a href="https://medium.com/transforming-digital/using-apple-foundation-models-in-filemaker-ba25d6c80739">Using Apple Foundation Models in FileMaker</a> was originally published in <a href="https://medium.com/transforming-digital">Transforming Digital</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What if users could ask questions the way they think?]]></title>
            <link>https://medium.com/transforming-digital/what-if-users-could-ask-questions-the-way-they-think-68f1e4d559c7?source=rss----ae52702e0e12---4</link>
            <guid isPermaLink="false">https://medium.com/p/68f1e4d559c7</guid>
            <category><![CDATA[claris]]></category>
            <category><![CDATA[filemaker]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[filemaker-2025]]></category>
            <dc:creator><![CDATA[Ian Jempson]]></dc:creator>
            <pubDate>Tue, 08 Jul 2025 16:19:27 GMT</pubDate>
            <atom:updated>2026-07-13T12:12:01.346Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>My Top 5 Features in FileMaker 2025</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QxYfDEBiYzYq6NxY3bkA9g.png" /></figure><p>“Show me all the contracts from Q3 that mention sustainability”</p><p>It’s a simple question. One we’ve heard countless times. But in most systems, that kind of request sets off a chain reaction: custom search interfaces, scripted logic, filtered layouts, and those manual workarounds when the tech can’t keep up.</p><p>As FileMaker developers, we’ve built those workarounds. They worked, but they came with a cost: time, complexity, and constant friction.</p><p><strong>FileMaker 2025 changes the equation.</strong></p><p>These five new features don’t just add capability, they remove entire layers of complexity. They mark a shift from users adapting to the platform, to the platform adapting to how people actually think and work.</p><p>Here are the five game-changing features that eliminate complexity and unlock new possibilities:</p><p><strong>1. Perform Find by Natural Language:</strong> Users can now search the way they speak: <em>“Show me invoices from last quarter that are overdue”. </em>No need to learn complex syntax.</p><p><strong>2. Generate Response from Model</strong> : Provides the foundation for intelligent software agents in FileMaker with dynamic, AI-powered text generation built right in.</p><p><strong>3. Semantic Search on Server</strong> : Semantic search isn’t new, but now it’s fast, scalable, and ready for production use.</p><p><strong>4. PDF Text Extraction</strong> : Pulling raw text from PDFs directly in FileMaker lets you automate parts of document workflows that used to rely on manual copy-paste.</p><p><strong>5. Go to List of Records</strong> : Quietly powerful. A small addition with big impact, this feature streamlines navigation and simplifies UI logic.</p><p>Each of these features replaces entire categories of custom scripting and UI scaffolding. Let’s dive into how they transform development and what they make possible for the people who use your apps.</p><h3>1. Perform Find by Natural Language: Search Finally Speaks Human</h3><p>Remember training users on FileMaker’s Find mode? Teaching field names, operator syntax, and how to build complex queries? And then answering the inevitable “Why can’t I find this record?” calls?</p><p><strong>Perform Find by Natural Language</strong>, a new script step, eliminates that entire learning curve. Users just describe what they need in plain English, and FileMaker 2025 interprets their intent automatically.</p><p><strong>The Old Way:</strong><br>A project manager trying to find active projects assigned to Sarah that are behind schedule had to enter “Active” in the <em>Status</em> field, “Sarah” in the <em>Assigned_To</em> field, and use date operators in <em>Due_Date</em> . All the time thinking “where do I put that Omit”.</p><p><strong>The New Way:</strong><br>They simply type: <em>“Show me Sarah’s active projects that are behind schedule.”</em> FileMaker gets it — and finds exactly what they need.</p><p><strong>Business Impact:</strong></p><ul><li><strong>Zero learning curve</strong> - New users can search immediately, no training required</li><li><strong>Reduced support load</strong> - Fewer “how do I search for…” help desk tickets</li><li><strong>Better data engagement</strong> - Users explore more when search feels natural</li><li><strong>True self-service</strong> - Non-technical users can answer their own questions</li><li><strong>Improved adoption</strong> - Lower friction = more people actually using the system</li></ul><p>This isn’t just easier search. It’s a shift in how people engage with data. When finding information feels like asking a question, users stop thinking about <em>how</em> to search and start discovering what matters.</p><h3><strong>2. Generate Response from Model: The Gateway to Intelligent Agents</strong></h3><p>Imagine if your FileMaker app could draft summaries, write emails, or respond intelligently to inputs — without hardcoded scripts for every variation.</p><p><strong>Generate Response from Model </strong>brings that power into reach. Using AI text generation natively, developers can now build dynamic, responsive experiences with minimal effort.</p><p><strong>The Old Way:</strong><br>Creating templated text responses or dynamic summaries required scripting, global fields, calc fields, and tedious string assembly.</p><p><strong>The New Way:</strong><br>One script step with a prompt like <em>“Summarize this customer’s recent activity in a friendly tone”</em> — and FileMaker generates it.</p><p><strong>Business Impact:</strong></p><ul><li><strong>Accelerated development</strong> - Build adaptive features faster</li><li><strong>Personalized user experiences</strong> - Dynamic text tailored to context</li><li><strong>Smarter automation</strong> - AI can respond to variable situations</li><li><strong>Lower barrier to AI</strong> - No external services required</li><li><strong>Future-ready platform</strong> - Foundation for software agents</li></ul><p>This is more than text output. It’s the first step toward apps that understand and communicate like people.</p><h3><strong>3. Semantic Search on Server: Breaking Through the Performance Barrier</strong></h3><p>Semantic search has been around for a year, but it had limits. It was powerful but slow, and not suitable for production at scale.</p><p><strong>Now, it’s fast, server-based, and enterprise-ready.</strong> Semantic Search on Server brings natural, meaning-based retrieval to FileMaker without the performance bottlenecks.</p><p><strong>The Old Way:</strong><br>Developers built keyword-based search layouts, ran slow client-side scripts, or used complex filtering logic with limited results.</p><p><strong>The New Way:</strong><br>Users can search conceptually, <em>“contracts about environmental impact”</em>, and get relevant results instantly, even if those exact words don’t appear.</p><p><strong>Business Impact:</strong></p><ul><li><strong>High-performance search</strong> - Fast enough for real-world use</li><li><strong>Meaningful results</strong> - Goes beyond exact-match keywords</li><li><strong>Scales to enterprise data</strong> - Run across large datasets seamlessly</li><li><strong>Improved user trust</strong> - Search that feels intuitive and accurate</li><li><strong>Less dev overhead</strong> - No need for advanced indexing workarounds</li></ul><p>Now, finding the right information isn’t about what words users type — it’s about what they <em>mean</em>.</p><h3>4. GetTextFromPDF: Automate the Last Manual Mile</h3><p>It doesn’t extract structured data. It’s not full OCR. But <strong>GetTextFromPDF</strong> still unlocks major gains.</p><p>You can now pull raw text from PDFs directly within FileMaker — opening the door to automation where manual copy-paste used to be the norm.</p><p><strong>The Old Way:</strong><br>Developers relied on users to manually read PDFs and enter data, or built integrations with external tools just to extract text.</p><p><strong>The New Way:</strong><br>One function extracts raw text from a PDF - ready for parsing, review, or storage.</p><p><strong>Business Impact:</strong></p><ul><li><strong>Faster workflows</strong> - Reduce manual steps</li><li><strong>Less data entry</strong> - Automate your document intake</li><li><strong>Better consistency</strong> - Fewer copy-paste errors</li><li><strong>Simpler integrations</strong> -Keep everything inside FileMaker</li><li><strong>Improved document insight</strong> - Make PDFs more searchable</li></ul><p>It’s not a silver bullet but it replaces a tedious, error-prone step with automation that’s good enough to matter.</p><h3>5. Go to List of Records: Small Change, Big Win</h3><p>This one might fly under the radar, but <strong>Go to List of Records</strong> is a huge quality-of-life improvement for developers.</p><p>Now you can programmatically take users to a specific list of records — without complex UI tricks, global variables, or scripted loopback workarounds.</p><p><strong>The Old Way:</strong> Navigating users to a specific set of records required elaborate scripting — performing finds, managing found sets, handling edge cases where records might be in different contexts, and building conditional logic to ensure reliable navigation.</p><p><strong>The New Way:</strong> <strong>Go to List of Records</strong> With one step, go straight to a found set defined by record IDs. It’s simple, clean, and native.</p><p><strong>Business Impact:</strong></p><ul><li><strong>Reduced development costs</strong> - Eliminate hours of custom navigation scripting</li><li><strong>Faster project delivery</strong> - Standard navigation patterns instead of custom solutions</li><li><strong>Lower maintenance burden</strong> - Simple, reliable navigation reduces ongoing support needs</li><li><strong>Developer delight</strong> - It just works</li><li><strong>Better integration capabilities</strong> — Simplified connection points for web services and external systems</li></ul><p>It’s not flashy, but developers will love it and users will feel the difference without even knowing why.</p><p>These five features mark a turning point for FileMaker. We can now build solutions that think like users, work like businesses, and fit naturally into the digital world. Developers can stop asking “How can we make this work?” and start asking “What should this do?”</p><p>For businesses, that means solutions on par with modern SaaS apps. For developers, more time building value. And for users, tools that adapt to them — not the other way around.</p><p>FileMaker 2025 doesn’t just add features. It removes friction. And that opens the door to what’s truly possible.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2-Ej447O9CtBma3exnGuag.png" /><figcaption>A sneak peak at my next blog post</figcaption></figure><p>My next post will provide a deep dive into your LLM hosting options. From Claris Server to Anthropic to AWS Bedrock, I’ll outline all the pros and cons.</p><p><em>I write a weekly newsletter on putting AI into real business systems, mostly FileMaker, mostly running locally. Free, and I write it myself: </em><a href="https://ianjempson.substack.com/subscribe"><em>subscribe</em></a><em> at ianjempson.substack.com.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=68f1e4d559c7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/transforming-digital/what-if-users-could-ask-questions-the-way-they-think-68f1e4d559c7">What if users could ask questions the way they think?</a> was originally published in <a href="https://medium.com/transforming-digital">Transforming Digital</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[FileMaker Semantic Search: 40x Faster with Hybrid Techniques]]></title>
            <link>https://medium.com/transforming-digital/filemaker-semantic-search-40x-faster-with-hybrid-techniques-3acb8d9f470f?source=rss----ae52702e0e12---4</link>
            <guid isPermaLink="false">https://medium.com/p/3acb8d9f470f</guid>
            <category><![CDATA[filemaker]]></category>
            <category><![CDATA[semantic-search]]></category>
            <category><![CDATA[claris]]></category>
            <category><![CDATA[performance-improvement]]></category>
            <category><![CDATA[database-search]]></category>
            <dc:creator><![CDATA[Ian Jempson]]></dc:creator>
            <pubDate>Fri, 06 Jun 2025 11:25:00 GMT</pubDate>
            <atom:updated>2026-07-13T12:08:54.519Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>From 80 seconds to 2 seconds for 900,000 records</blockquote><p>I’ve spoken to several people who found that they were getting poor search results when trying the Semantic Search script steps in FileMaker. Speed of search is often an issue as well.</p><p>This led me to perform some experiments to find out how much we can improve things. Can we have our cake, in the form of higher quality search results, and eat it too, in the form of fast search?</p><p>The short answer is yes.</p><h3>The Dataset — 900,000 records</h3><p>For this experiment I needed a reasonably large dataset so I turned to kaggle.com, a site focused on machine learning datasets. I chose a csv dataset with 900,000 records. It’s from Vestiaire, a second hand fashion site.</p><p><a href="https://www.kaggle.com/datasets/justinpakzad/vestiaire-fashion-dataset/data">Vestiaire Collective Dataset</a></p><p>Converting csv to FileMaker is trivial so I won’t go into too many details. I converted the csv file to FileMaker then added a table for the vector embeddings. Actually, since I’m doing speed testing, I added several tables for vector embeddings. That allows me to easily compare speed and quality of search results.</p><p>Our schema looks like the following. Obviously those extra embedding tables aren’t needed in most cases. In production I’d also store the embeddings in a separate FileMaker file to allow a bit more granularity in how we configure our backups.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LspcAaXURQ1HuAQPd34LfQ.png" /></figure><h3>Populate Embeddings</h3><p>My script to populate the embeddings with the all-MiniLM-L12-v2 model looks like the following. It can run either locally or server-side. I’m using the MaxRecPerCall parameter to speed up the embedding process by using a larger than default value.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/854/1*fxnYeIBIdO60IDUjCHieHw.png" /></figure><p>The data, in the product description table, looks like the following:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/980/1*Tbem6hfmaeIjv1IlXfHpsw.png" /></figure><p>As you can see, we’ve got around 900,000 records so this makes for a good test. For the initial test I’m going to do a standard semantic search for the matching records. In this case my server is running on an M2 Mac Studio with 32 GB RAM and the client is an M1 MacBook Pro. The MacBook is on my wifi network, so this would be faster if it were on ethernet.</p><h3>Initial Performance — 1 minute 20 seconds</h3><p>It comes in at around 1 minute 20 seconds for the first search across 900,000 records. Subsequent searches are much quicker in the 20 second range. Once we’ve performed a search and FileMaker has the information in the local cache, it’s much better. But 20 seconds is still a long time to wait.</p><p>I’m running a local server for embeddings. I wrote it in Python, but you’ve got several options for local servers. Ollama, LMStudio are currently available and easy to configure.</p><h3>Semantic Search Script</h3><p>Here’s my search script. I configure my AI account. The script also copes with searching on a found set of records or the full record set and provides a basic timer for performance comparisons.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/849/1*YJ_a-PlUJI7rfud12aDp7w.png" /></figure><p>You’ll also notice it’s calling another script “insights api rerank”. After the semantic search I’m using a reranking API to sort the records in order of similarity. This will be a separate blog post. Let me know if you want more details.</p><p>The obvious first step for performance improvement is to perform the search server-side with Perform Script on Server (PSOS). That can make a big difference. We’re not dragging 900,000 large records across the network to search. However, in this case I’ve not done that. The next release of FileMaker Server will perform semantic search on the server by default, so there will be a handy performance increase built into the product soon.</p><p>To get from over a minute to 2 seconds requires a different approach. I’m going to apply a hybrid search technique. Rather than doing our semantic search on 900,000 records I’m going to do an indexed search first to narrow down the records, then perform the semantic search on the smaller set of records. So we’ll actually perform semantic find on maybe 10,000 or 20,000 records and that’s a lot faster.</p><h3>Making it Faster</h3><p>Indexed searches in FileMaker are very very fast. So our approach is to look at our search query to extract information that could be used to perform the indexed search.</p><p>If our search criteria is like the following:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/571/1*WI7bV3HnuWyuCd2O32EhBw.png" /></figure><p>We can see that there are several attributes that we could possibly perform an indexed search on. For this example we’re using product colour and brand. So we’d search on the brand “Alexander McQueen” and product colour “black”.</p><p>Our search process now changes a bit. We need to extract these attributes from the query, perform a FileMaker Find, then we perform semantic search.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zVtyuIA1OsW1Ylf0i2KykA.png" /></figure><p>The extraction script builds a query, then sends it to an LLM and asks it to extract structured data from the criteria. This returns JSON which is parsed by a FileMaker script to perform the Find.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/580/1*KR2yj47qX6FHU-LzRZHS-w.png" /></figure><p>In this case, I’m using a small model, gemma3:1b running locally in Ollama. Gemma3 supports returning structured data, which is a requirement for this technique. Not all LLM models are capable of returning structured data so choose one that does. I’ve also chosen the 1b variant of Gemma because it is small and fast. It returns a response within a second. When I use the 27b variant of Gemma it takes 10–15 seconds even for an easy query like this one. However the larger variants are more accurate. So it’s a trade-off for each use case. You can see that the Extracted Attributes above include “condition”:”excellent” even though i make no mention of condition. This is an example of hallucinations and the larger model wouldn’t make that mistake.</p><p>The extraction script looks like the following…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/924/1*8fTSKEYGLIgfkLo5v0Dxqg.png" /></figure><p>If no attributes were found in the query string, we perform semantic search on the full set of records. Since that search is on the full dataset it’s obviously going to be the same speed as our original script.</p><h3>The Results</h3><p>Here’s what the process looks like after adding the new functionality. 2–3 seconds searching on 900,000 records is pretty good going I think!</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fplayer.vimeo.com%2Fvideo%2F1091159961%3Fapp_id%3D122963&amp;dntp=1&amp;display_name=Vimeo&amp;url=https%3A%2F%2Fvimeo.com%2F1091159961&amp;image=https%3A%2F%2Fi.vimeocdn.com%2Fvideo%2F2023923581-0460497fdffa2c604820b7c48897dba995cdf95e71a2114328b690894a4b48ff-d_960%3Fregion%3Dus&amp;type=text%2Fhtml&amp;schema=vimeo" width="1006" height="872" frameborder="0" scrolling="no"><a href="https://medium.com/media/3d133508b574da183453b0a01ce21b07/href">https://medium.com/media/3d133508b574da183453b0a01ce21b07/href</a></iframe><p>I’ve shown how we can apply a hybrid search technique to speed up FileMaker semantic search considerably. This technique can be done with current shipping product versions and implemented quickly.<br>Since LLMs are running locally in my example, there is no data sharing outside the organisation.</p><p>My next post will go into some detail on the reranking process. This provides a more accurate ordering of the search results than the standard cosine similarity approach built into FileMaker semantic search.</p><p><em>I write a weekly newsletter on putting AI into real business systems, mostly FileMaker, mostly running locally. Free, and I write it myself: </em><a href="https://ianjempson.substack.com/subscribe"><em>subscribe</em></a><em> at ianjempson.substack.com.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3acb8d9f470f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/transforming-digital/filemaker-semantic-search-40x-faster-with-hybrid-techniques-3acb8d9f470f">FileMaker Semantic Search: 40x Faster with Hybrid Techniques</a> was originally published in <a href="https://medium.com/transforming-digital">Transforming Digital</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Improving FileMaker’s semantic search…]]></title>
            <link>https://medium.com/transforming-digital/improving-filemakers-semantic-search-f0812ed678d5?source=rss----ae52702e0e12---4</link>
            <guid isPermaLink="false">https://medium.com/p/f0812ed678d5</guid>
            <category><![CDATA[filemaker]]></category>
            <category><![CDATA[claris]]></category>
            <category><![CDATA[semantic-search]]></category>
            <dc:creator><![CDATA[Ian Jempson]]></dc:creator>
            <pubDate>Mon, 28 Apr 2025 15:52:04 GMT</pubDate>
            <atom:updated>2025-04-28T15:52:04.371Z</atom:updated>
            <content:encoded><![CDATA[<p>Claris FileMaker implements semantic search in a very “FileMaker-like” way. It’s easy to use and feels like it fits in with the way FileMaker does things. Idiomatic FileMaker if you will.</p><p>However when people try it for the first time they’re often a bit disappointed by the results. It’s not a silver bullet to solve all your search issues. The good news is that there are things we can do to make it perform better. Some are relatively simple and others require a bit more work.</p><p>I’m writing a series of posts tackling these areas. I’ll be releasing them at the rate of one a week, on Monday. Claris have got some improvements in the works and this series will lead nicely into those.</p><p>The topics I’ve got planned are:</p><ul><li>Choosing embedding models to get more accurate search results.</li><li>Hybrid search — combining keyword and semantic search</li><li>Fine tuning embedding models — when you need something more specific.</li><li>Reranking — you’ve got the search results, but how do you know which are best?</li><li>Performance — how to make embedding and search faster.</li><li>Putting it all together for a specific use-case.</li></ul><p>I’m using one data set for this series. It’s a dataset of fashion products for sale from Vestiaire and there’s approximately 900,000 records. Given the number of records, it provides plenty of scope for exploring these topics.</p><p>I look forward to hearing what everyone thinks. Are there any other topics I should add to the series?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f0812ed678d5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/transforming-digital/improving-filemakers-semantic-search-f0812ed678d5">Improving FileMaker’s semantic search…</a> was originally published in <a href="https://medium.com/transforming-digital">Transforming Digital</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Naming Things in FileMaker]]></title>
            <link>https://medium.com/transforming-digital/naming-things-in-filemaker-68f49541c8e2?source=rss----ae52702e0e12---4</link>
            <guid isPermaLink="false">https://medium.com/p/68f49541c8e2</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[filemaker]]></category>
            <category><![CDATA[naming-things]]></category>
            <dc:creator><![CDATA[Ian Jempson]]></dc:creator>
            <pubDate>Mon, 23 Dec 2024 10:50:35 GMT</pubDate>
            <atom:updated>2026-07-13T12:14:29.950Z</atom:updated>
            <content:encoded><![CDATA[<p>FileMaker naming conventions are a well-trodden topic, so why are we heading down that path again? In a word, agents, or more specifically AI agents.</p><p>Most discussions on naming conventions list a number of users or consumers of the convention. Typically it goes something like the following:</p><ul><li>You, the developer</li><li>Future you, when you revisit the system a year from now</li><li>Other developers, who need to understand what you’ve done</li><li>Clients, who may want to understand the system</li><li>Auditors, possibly for ISO certification or other needs</li></ul><p>AI Agents are going to play a huge role in the software landscape and it’s already starting to happen. Agents communicate with Large Language Models (LLMs) and perform actions on their behalf. They add new capabilities to the LLM. Examples might include an agent that checks the weather in a given city. Obviously the LLM has no knowledge of the weather, but it can ask a weather agent when it needs to know.</p><p>You’re probably wondering what this has to do with FileMaker naming conventions. The answer is that someday, probably not too far in the future an AI Agent may need to talk to your FileMaker system, and when it does it’s going to need to understand the data structure. So the AI Agent is now a new addition to the list of information consumers interested in the naming convention.</p><p>Most suggestions for field naming recommend avoiding any characters that aren’t safe in SQL. This is a pretty good start. LLMs are really good at understanding SQL.</p><p>There are a couple of “FileMakerisms” that many developers employ which help development in FileMaker but cause problems with LLMs.</p><p><strong>Leading underscores</strong>. Using leading underscores to indicate record keys is a common practice that doesn’t play well with LLMs. They get confused by the underscores and have difficulty creating sensible queries.</p><p><strong>Ambiguous field names</strong>. This problem is a more general one, in that ambiguous field names are difficult for all consumers of the naming convention. LLMs have difficulty understanding the distinction between different fields and their purpose, leading to queries that may use the incorrect fields. These things are non-deterministic and we’re not explicity saying which fields they should use in queries.</p><p>The following screenshot of a trivial example shows some bad habits. An LLM would have difficulty producing a useful query with a structure like this. If asked to report on total sales it would be more likely to give you the total of the selling price (amount) rather than what you really wanted. I’ve seen this happen on a couple of reporting projects.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8A5_YQ7Qi8Sm7xyM9XBMyw.png" /><figcaption>Don’t do this!</figcaption></figure><p>Here’s a better example. Again, it’s a toy example, but illustrates something that an LLM would be able to work with.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4HQt_4U_tFITVoxBp3jlIw.png" /><figcaption>A slightly better example</figcaption></figure><p>I’m not advocating for a wholesale change in the way we all name things, but please bear in mind that sooner or later your system will probably interact with an LLM and it’s best to avoid confusion.</p><p><em>I write a weekly newsletter on putting AI into real business systems, mostly FileMaker, mostly running locally. Free, and I write it myself: </em><a href="https://ianjempson.substack.com/subscribe"><em>subscribe</em></a><em> at ianjempson.substack.com.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=68f49541c8e2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/transforming-digital/naming-things-in-filemaker-68f49541c8e2">Naming Things in FileMaker</a> was originally published in <a href="https://medium.com/transforming-digital">Transforming Digital</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>