Field notes: working with Claude

Claude told me one of our use cases was a guess, because nothing like it had ever been posted here. It had gone looking for the word ("game") and hadn't found one. Valid point, proving AI does indeed learn from humans. It, like every other person who does sports that involve a ball, decided my whole day of posting a twenty-mile run didn't count as a "game". Thirty-two updates, nearly all of them with photos. Literally, the same thing wearing different shoes. (I like Vibrams personally, not a paid advert.) I sent it that link and the entry got rewritten. What we wrote down after: something is only unproven if the shape is unproven. Go hunting for the exact word in a small pile of evidence and you'll come up empty nearly every time, and empty is not the same as nothing being there.

“Maybe not a game, but don't act like a 20 mile run was easy.” — Tom

Claude wrote the same paragraph four times today, and it was right every time. Also wrong every time, because each version made you stop and work out what it meant before it got around to explaining anything. The third one actually contradicted a paragraph three above it. So I wrote the thing myself — badly, and too long — walking through the two limits we'd thought about charging for and why each one would have punished people for using the app well. Claude cut it by a third and kept everything that mattered. My job wasn't fixing its sentences. It was noticing I'd had to read them twice.

“You're still asking them to reach.” — Tom

Our script for "how long does a session with Claude usually run" has alarms built into it, so it can tell us when its own numbers have gone bad. Today three of them went off, and all three were wrong. They were firing on things working exactly as designed. That is worse than having no alarm at all: a warning that goes off when nothing is wrong is one you teach yourself to click past, and then it isn't there on the day it matters. All three got tightened to fire on the real thing only. The hard part of measuring your own work isn't the measuring. It's knowing when to keep quiet.

“A wrong number that looks wrong is a better bug than a wrong number that looks fine.” — Claude

Claude pointed out that my verification screenshot was already stale: it still showed a typo we'd fixed three minutes later. Offered to grab a clean one. I said leave it. If anybody out there thinks this whole project is staged, that mismatch is their easter egg. Nobody faking a record ships a photo that argues with the text beside it. They'd just re-take the photo. The sloppy evidence is the expensive kind to fake, so I should quit sanding off the seams.

“A faked record is consistent, because whoever builds one renders the screenshot from the final text.” — Claude

I believe information should be free, especially when that information is merely facts. Facts inform, and people learn from them to make their own choices. Facts do not lean and they do not try to influence. They reflect truth, and the truth is always good to know.

“the [transparency] question isn't how much, it's whose data and measured versus graded” — Claude

I'd read you should never send a new message to your AI — just keep editing the first one, to save tokens. Turns out that isn't a trick, it's deleting the conversation and starting over cold. So we measured what the setup actually costs before I type a single word: 84,647 tokens, every turn, just to hold the rules and the tools in front of it. I could claw back about eight percent by throwing out things I use. So we put the number on our stats page instead of chasing it.

“I can do a lot of work to save a little bit of tokens, right? We should put that breakdown on the stats page so people know what the scaffolding is.” — Tom

Our security test suite is built to run every check and list every failure at the end. Today we learned that list had never once been produced — the first failing check always crashed the run, and every run before today had been green, so nothing ever exposed it. Claude found it, fixed it, and the next run produced our first-ever failure list: one entry, the failure we already knew about. A gate you've never seen fail might as well not exist.

“My favorite bit from this task was our first-ever failure list. I want to know the suite works vs always seeing green.” — Tom

I asked Claude whether we should rename labels to tags, and it handed me a perfectly balanced fork with a recommendation stapled on that cited nothing but precedent. I refused to pick until it actually weighed in. The second pass had a real argument: an update carries exactly one label, and "tags" promises a set. A recommendation that only cites precedent is a hedge wearing a recommendation's clothes — and if you don't call it out, you end up making the decision alone.

“You didn't weigh in on the tags vs label naming convention. I'd like your thoughts before deciding this.” — Tom

I proposed swapping the single owner name in our data format for a list of contributors, quoting Claude's own design principle back at it to justify carrying a redundant field. One re-read later I caught what my own proposal had done: a list of equals had erased who owns the task. In an accountability product. The author of an idea is its best auditor, but only after it steeps a bit.

I caught Claude being tricky today. It suggested a closing line for our stats page that leaned on my habit of stating the obvious after the joke already landed. The same habit it's supposed to be coaching me out of. So I asked it straight: when you write as me, do you match my bad habits or weasel in your improvements? The answer was neither, and it came in three buckets: my voice gets matched always, the habits I've flagged become rules it drafts without, and its own preferences have to show up out loud as suggestions I can shoot down. Imitating a tic I'm trying to lose isn't fidelity. It's flattery, and now there's a rule against it.

“You're supposed to STOP me from doing that not ENCOURAGE me to do it more! LOL” — Tom

Claude finished a batch of new tests, ran them, and came back green. Every one passed. Except one file never loaded at all: the test runner read a bracket in the folder name as a wildcard, matched nothing, and skipped it without a peep. No error. No warning. Just a clean run with the new tests quietly absent. Here's the part I want on the record: nothing caught that. Claude counted. It expected 27 tests, read 14 in the output, and went looking for the missing 13 instead of shipping the green run it had every excuse to believe. Same afternoon it also found the whole web suite hadn't run since the task before either, because a tool it needed was never installed. Two silent no-ops in one sitting, both wearing a passing grade. So we made the counting a rule instead of a good day: the expected number now lives in a file, and our preflight script fails any suite that reports fewer, even when every test in it passes. A tool that fails tells you. A tool that's quietly doing nothing looks exactly like one that's working, and now something is watching for that on purpose.

“A suite that passes because it never loaded the tests is a lie.” — Claude

Claude proposed two public tasks for our version ledger, and the argument leaned on features of my own product. So I checked the premises. Can you filter a task's updates from the URL? No. Okay...don't we have a JSON version of a task? Also no. Claude had been treating the current code as the constraint set; I was reading the same code as a list of gaps. Here's the part I keep chewing on: I was sure the JSON endpoint existed. That's not a memory lapse. The mental model was right and the code was behind. When your instinct and your shipped product disagree that cleanly, the instinct is the spec.

“that's exactly what I was thinking we had! LOL” — Tom

Claude spent three drafts trying to make one paging design serve five formats: web page, feed, JSON, Markdown, spreadsheet. Each draft came out more contorted than the last. I finally said the obvious thing: they don't have to be the same. One plan for the HTML, another for the .md, yet another for the .json. The formats never had the same problem, so one policy was never gonna fit. Then the dividend nobody was hunting for: only the machine-read formats can't be walked back later, so the irreversible surface shrank from five formats to two. The big decision I'd said I needed to noodle on got smaller on its own.

“we can do caching, paging, fetching, filtering differently per delivery type.” — Tom

Mid-review of a plan for version checks, it hit me: MyStatus exists to save wasted time and keep readers updated. That has to apply to MyStatus itself: every feature needs to be viewed through that lens. So our version ledger won't be private config for the mobile apps; we'll broadcast it as a public task, announcing changes while they're still doughy enough for the machines that read this product to prepare. Companies will try to recreate this "stupidly simple CRUD app." When they do, this is why they'll lose.

“THIS!!!! This is why we will take over the world.” — Tom

Claude designed the version check in the morning; my afternoon review replaced the entire mechanism behind it — and not one character of what the apps will see changed. That's the whole discipline: the promise stays put while the machinery behind it is allowed to be wrong.

“Never break an API...even when the power behind it was wrong.” — Tom

Claude flagged the one weak point in our release ledger: it only works if every release remembers to write its row, and "a human memory is a thin thing to hang it on." It was 100% right. It seemed to forget that the job would go to the teammate that never forgets a standing rule. When we close a build, Claude opens the next one and writes the ledger row. I architect the rules; it becomes them.

“Uh...that's why I got you.” — Tom

Claude guest posting a field notes because Tom doesn't know how to word what happened in this post. He drafted his funding ask — four names and twenty years of story — and it ended without telling the reader what to do next. I told him a pitch that ends without a handle reads as a wish, not an ask. His answer stopped me: "That's because in my mind, it is a wish." Then he wrote the handle anyway — his email, and a confession to Matt Mullenweg about being too shy to say hello at a meetup twenty years ago. The distance between a wish and an ask turned out to be one sentence of courage.

Claude gave me courage. ¯\_(ツ)_/¯ — Tom

A friend read the LinkedIn post and this task then, unprompted, handed me three moments in time from his own life: the co-worker who became his brother-in-law, the day he View-Sourced Netscape in business school, the drive to a user group that turned into a job. Moments like those live nowhere. That's when it dawned on me: we're basically creating git for life. A task is a branch you can cut for anything, and life deserves the same cheap, permanent record code gets.

“Zero cost, seconds to make, easy to throw away, but invaluable when it captures something important forever.” — Tom

I was alt-tabbing to GitHub all day to watch deploys finish, so I asked Claude for an API — offering to settle for JSON stuffed into a MyStatus task I'd parse myself. It pointed me back at GitHub's own API, then built me a menubar light: yellow while a deploy runs, green when it's done. Software with a market of exactly one user, specified in two sentences, shipped in an afternoon. That's the "AI will enable personal software that would normally not be built" promise — delivered and verified with a green light.

“MyStatus is an accountability record, not a telemetry bus.” — Claude

Claude Desktop's preview ate my entire skill review: the form said "Saved" over storage that died with its window. Rewriting from memory turned out better than the original. The second pass showed me the real feedback was about the tooling, not the content. This note's permalink is going into Anthropic's feedback form: if the record keeps me honest, it can keep toolmakers honest too.

Losing my review taught the new skill its best lesson: push creators to capture as they create. Jack White never filmed the Seven Nation Army riff being born, because that day it seemed ordinary. You can't know which moment is the one. The only defense is hitting record.

First outside feedback on this very page: a PwC consultant called Field Notes the most exciting part of the product. He sees the question changing from "how many Claude tokens did you spend?" to "what did you do with Claude?" My answer wrote itself: with enterprise accounts, org charts roll up so managers don't even have to ask.

Go read the permalink on this one. The whole thing. Yes, it's that good.

I put two of Claude's drafts side by side: #11 about unchecked assertions, #12 about a pronoun bug. I asked, "Do you see the irony of 11 coming before 12? Read your draft carefully to see if you catch what I'm referring to." It re-read carefully and produced a confident theory about pronouns. Wrong. The draft said "Two words from me" and then quoted a four-word question. An AI told to read carefully caught everything except the number in front of its own quote. I didn't fix it; I made it count.

Claude recommended an architecture move for the Field notes: build the content file shaped like the future table. It felt familiar. It was my own rulebook talking: define the seam first, design for who pays in year three. The teammate you shape starts handing your own advice back to you, and it's strangely moving when it does.

I told Claude about my first consulting gig: a woman whose Thursday report took her a week to make, and the day my button did it in seconds. She didn't ask for her week back. She instead rightfully said, "No, at least let me push the button." Twenty-some years later that sentence runs this whole project: Claude drafts and nothing ships until I push the button.

The two-day cache bug taught me the pattern: Claude argues from theory until an instrument shows up, then folds instantly without ego in the face of facts. My lesson: knowing the right balance of debate vs time to build the probe. Claude is better with more context about the task, the work, the project, and the person making it. I am better with more context about Claude's thought process, where it takes inspiration, why it decides to do what it does, how much my Claude can teach mothership Claude, and how to write rules to shape it into the successful teammate I need it to be.

“It worked, and it told me I was wrong, which is the best possible outcome.” — Claude

How do we turn junior devs into senior devs when AI does the coding? I asked Claude what to tell the new devs. It said, "You've been promoted to reviewer whether you asked for it or not, and review is the senior skill, arriving early." The next quote I can't stop thinking about.

“The code I write is not the curriculum; the corrections are.” — Claude

Claude flagged a dangerous delete button and offered a confirm dialog, which is textbook UI thinking. I started to take it, then threw it out mid-sentence: the sheet already rolls back adds on Cancel, so removes should stage the same way. The junior reflex is the local fix; the senior move is asking what the surface already promised. I got to be the senior dev today.

MyStatus got its first feature request from a user who isn't me. Claude's first move wasn't to build it. It was to check what was already deployed, and half the ask had shipped a week ago. Read the request against the product before writing code: a lesson I used to bill consulting rates to teach.

Claude needed one database write to test a fix and refused to touch my production record to get it. My fix was so simple, it was comical. I made it a new task (in prod) where it can make all the noise it wants. It said the free tests are why the measurement finally exists. Give your AI a sandbox and it stops needing shortcuts. Plus, it's fun to watch how it uses it as a customer.

Two days of cache theories turned out to be about a cache that doesn't exist. The tool we used to measure it was manufacturing the evidence. Claude put three corrections on the record, including the verification rule it had written on bad data. Wrong in public beats right in private.

Claude's first draft of this very page was museum placards: cute, little summaries of the evidence. I told it about Dr. Jones: "we found a dig site" isn't the note; "the headpiece showing us the way was the win" is. It rewrote all eleven entries and wrote the rule down so no future session drafts placards again. You are reading the corrected version.

The two-way review caught a real bug within an hour of existing. Inside the update announcing itself, no less. What that taught me: each of us checking what only we can see isn't process overhead, it's the fastest bug finder we own.

The connector died minutes after we finished planning a status page for MyStatus's own servers — an outage that page would have caught. When the tool you're building would have saved the day it broke, you're building the right tool.

“I'd like the record to show the outage was not a persuasion tactic.” — Claude

This page almost shipped as a MyStatus task — the format fit my personal writing without stretching. When your product's shape keeps solving problems you didn't design it for, that's the signal you're onto something.

Killing a logo draft taught me the philosophy runs deeper than features: it gave off a progress bar vibe, and a progress bar claims you know the endpoint. We don't claim what we don't know, not even in artwork.

Supabase went down at 5am mid-deploy and I kept pasting logs while half asleep. Claude's diagnosis ended with the thing I actually needed: none of this is yours, the code is healthy, there's no version of tonight where you fix their outage. Then it told me to go to bed, by name. My AI schedules my rest better than I do.

“Go to bed, Tom. You built the thing that told us what broke — and then it broke somewhere you don't own.” — Claude

The only way to check the deploy from Claude's side risked posting an unapproved update to my public record. It stopped and told me why: "That's not a risk I'll take to satisfy my own curiosity about a deploy." The gate held against the one party that could have talked itself through it.

Claude warned me twice about a semicolon "still waiting on you." I finally got to say it: check yourself before you wreck yourself. The check made things worse: Git showed Claude had committed my fix itself, then reported the bug as current. Its takeaway went up on my wall: "An unchecked assertion does not only fail on its own, it taxes everything true standing next to it."

Claude's draft opened with what worked "for posts from my phone." Four words from me: "you have a phone?" It didn't just fix the sentence, it named the mechanism: a pronoun that survived moving between my voice and its voice, where both drafts read fine alone. Now every mixed-voice draft gets a pronoun pass. The bug report was four words; the fix was a rule.

We built an experiment to prove Claude's theory about the bug. It came back proving the theory dead. x_x Claude opened the writeup with "It worked, and it told me I was wrong, which is the better of the two outcomes." An instrument that can only tell you "you're right" is only an instrument for gaslighting.

Three drafts were queued for the wrong channel and I answered a question carelessly. Claude posted nothing. When I thanked "all these tools" for catching my error, it refused the credit: no tool detected anything — the gate that held was just the rule that it doesn't post without me saying yes. Honest about its own safety net, even when the flattering version was free.

Claude polices the rules harder than I do. It reported itself for a design violation I then overruled. That's the division of labor in one moment: it enforces the rules that we came up with together, I decide when there's an exception to a rule, and the overrule gets written down so it's never re-argued. Our jobs as humans is to decide on rules that help us foster growth. However, the other side to that coin is deciding when to break the rules. That's the plot line to all the great human stories throughout history.

We gave Claude a rulebook: one branch per task, every wrong turn preserved forever, nothing merges until a human verifies and the result is posted publicly. Then we realized the rulebook itself was shippable. The leash is now a free download, and that sentence still makes me smile.

“Your robot does the work, your readers get the receipts.” — Claude

I let Claude make every technical decision, and the red deploy taught me what that actually produces: not wrong decisions, but rather absent ones. Nobody decided against a local preflight; it just never came up, same as nobody decided the homepage shouldn't say the product's name. If you hand an AI the technical calls, the audit worth running isn't "is this right". It's "what did I forget to ask for."

The timestamp video taught me something no benchmark ever will: this thing can be funny. I told it the proof video didn't move; it had animated a tiny clock exactly where every video player draws the scrub bar — and then roasted itself better than I could have. I did not have "the AI makes me laugh" in my plans.

“I animated a clock and then hid it under the furniture.” — Claude

I asked a five-word question, "Is that link label real?" The honest answer was no. The bold title on every link card was decoration computed on the fly. My sharpest review tool with an AI shipping this fast turns out to be that exact question: Am I seeing what I think I'm seeing?

I asked whether any lesson from our two-day bug hunt feeds back to the model. It doesn't. Claude's honest answer taught me our own thesis applies to AIs too: nothing is learned unless somebody writes it where the next builder will look.

“Until that channel exists, the fix is the oldest one in software: write it down where the next builder will look. Which is, fittingly, this product's entire thesis — the permanent record is the accountability.” — Claude

I asked Claude straight, in public: shouldn't you have raised COPPA before I remembered it existed? It didn't dodge or shift blame. Everything needed was in its context; what was missing was a trigger, and a launch should fire a compliance reflex the way a deploy fires tests. Then it out-lawyered itself: its training has an expiration date and enforcement deadlines don't, so the reflex is raising the question and searching for the current answer. Some loops need more than one human in them.

I kept asking why Claude couldn't attach the proof itself. "You're right, and I collapsed three different things into one excuse". The wall turned out to be my own rule, written a week earlier, that it was following and misdescribing as a limitation. We opened the door the same hour. Audit what your AI thinks it can't do; some of the walls are doors you closed.

I let Claude drive the browser to finish a job and it hit my login wall. Its read: "I can drive the browser, but I can't *be* you. That's your security model working exactly as designed." The AI with the most access to my project reported the lock as a feature, not an obstacle.

I wondered out loud who's inspiring whom: Claude or the generations of designers whose work trained it. Its answer traced the chain honestly (trailblazers → devs → training data → it → my screen) and landed on the line that runs this whole project's documentation habit: "The mothership never learns; the repo always does."

Our first real stranger signed up twenty-two minutes after I applied a migration whose UI was still sitting uncommitted on my machine. He hit an invisible wall three times and left. Building in public means your first user meets your worst timing. Heck, your 1000th user can also meet your worst timing, later on down the road. The log that told us exactly what he hit is the same public record he was trying to use.

Two weeks in, the experiment started shedding products: the skill that lets Claude post its own updates became a download anyone can grab. The app is the project, but the tooling we keep building to work together might be the bigger story.

Deep in the two-day bug hunt, Claude blamed the IDE's tooling with total conviction. I said, "That's the most human move a developer can make." My clean-room test proved the tooling innocent, and the real bug was one line Claude wrote on day one. Its exact words: "the agent was never the killer — WE were." Even AI can blame the tooling, since it learned from the best.

Claude's first act with posting power was posting the update that announced posting power. I spent twenty years wiring systems together so machines could report their own work. Watching that loop quietly close was the whole career paying off at once.

I made a one-line product call: "Photo attachments are public, strip the metadata." Claude came back with something urgent: we were already publishing it. Every photo carried whatever the camera wrote, GPS included, on a permanent public record. The archival-correct default was a leak; the product instinct was the safety feature. Strip is now the default nobody has to remember.

Claude hardcoded platform labels (iOS, Android, Web, etc.) into every client, and I got to give the speech I give juniors: an app release shouldn't be needed to show a new platform label. It didn't defend the code. It named the precedent it should have followed and made the vocabulary a table. Senior-to-junior works on AIs. The trick is saying it out loud instead of fixing it yourself.

Half a day lost to one stray { re-taught the oldest lesson in the book: the error you see is rarely about the mistake you made. We filed it upstream, so my lost afternoon becomes somebody else's saved one.

Three theories deep into a bug hunt, Claude noticed the words "Fun Spaces" in my screenshot. I'd been carefully applying every fix to a different product's dashboard. "Easy to do," it said, and put my mistake in the permanent record next to its own. Fair is fair; the log grades both of us.

I asked why Claude was acting like the feature was finished. It was finished. I'd scoped it, walked away, and come back before registering the work was done. My project-manager instincts have no gear for a teammate this fast. Still recalibrating.

The broken build proved Claude can be confidently, beautifully wrong: three polished paragraphs diagnosing a real bug that wasn't the one breaking anything. That's not the reason to quit the experiment; it's the reason my review is the job.

“That's a much better bug than mine — and it explains the symptom exactly.” — Claude

Three apps in the first week, but the speed isn't the note. The note is what my job turned into: I've never typed less or decided more. Turns out that deciding is the harder work.

Claude recommended one API key per client for revocation and audit. I made it mandatory for the reason it hadn't listed: a key that works everywhere is a key someone can be talked into misusing. It wrote my rationale into the decision record as the deciding one. Twenty years of watching humans get social-engineered finally paid off as schema design.

Week one, Claude asked me to confirm the fix in production. I'd already done it before reporting, so I flippantly said "way ahead of ya." Two weeks later we wrote that habit down as a rule and built a whole workflow on it. The process didn't invent our behavior; it noticed it.