[{"type":"garden","id":"blog/edit_links","title":"Edit Links","description":"","tags":[],"date":"2026-06-03T18:12:45.888Z","url":"/garden/blog/edit_links","content":"Why I have \"edit\" links on my site:\n\nI use my site's [search page](/search) as a public second brain in certain ways.\nWhen I write something up as a [TIL](/til) it was probably useful enough to be something I'll come back to again.\nBecause of this, occasionally I have updates or notice changes that need to be made to a particular page.\nWhen I realize this, it is almost always the best time to make the change.\nThe fastest way to do that is to make a quick file edit in GitHub, a tool with a reasonable experience for quick and minor changes.\nIt opens in the app on my phone and as a logged-in session on my computer.\nI make the edit, commit, the build runs and it's live.\nIf _you_ click it, it will bring you to a page to create a PR to the site.\nIf you're making a correction, thank you! It's an honor to have you as a reader.\nI hope you've gotten something positive out of my work or that it saved you time."},{"type":"garden","id":"blog/structure","title":"Structure","description":"","tags":[],"date":"2026-06-03T18:12:45.888Z","url":"/garden/blog/structure","content":"My blog has the following sections:\n\n## Search\n\n[`/search`](/search)\n\nSearch functionality across all the content on this site.\n\n## Posts\n\n[`/posts`](/posts)\n\nI view these as complete or polished pieces.\nThey are of varied quality, but most have been edited by me several times over and occasionally by a few others.\n\n## TILs\n\n[`/til`](/til) (short for \"Today I Learned\")\n\nI've seen several other folks write these types of posts.\nI sort of view them as notebooks.\nI write ideas and things I learn in them, but they're only a medium level of refinement at most, and some are just simple. straightforward things.\nThey usually have a medium amount of editing but quality varies.\n\n## Logs\n\n[`/logs`](/logs)\n\nLogs are short notes, thoughts, links, and occasionally tweets.\nThey capture fleeting thoughts from the day.\nSometimes, they lead to writing in other sections but are generally unrefined, unedited, incomplete, and sometimes wrong.\n\n## About\n\n[`/about`](/about)\n\nBrief and general, high level things about me.\n\n## Projects\n\n[`/projects`](/projects)\n\nSome of the more complete projects I've worked on.\n\n## Garden\n\n[`/garden`](/garden)\n\nA place for thoughts, ideas and essays I tend to.\n\n## Uses\n\n[`/uses`](/uses)\n\nThe software and hardware I use.\n\n## Now\n\n[`/now`](/now)\n\nWhat I am up to \"lately\".\n\n## Activity\n\n[`/activity`](/activity)\n\nRecent activity and updates on this site."},{"type":"garden","id":"inspiration/links","title":"Links","description":"","tags":[],"date":"2026-06-03T18:12:45.888Z","url":"/garden/inspiration/links","content":"- https://simonwillison.net/\n- https://thesephist.com/\n- https://xeiaso.net/\n- https://nikiv.dev/\n- https://maggieappleton.com\n- https://www.harrymackofficial.com/about\n- https://paulgraham.com/\n- https://sindresorhus.com/\n- https://stephango.com/\n- https://justjake.me/\n- https://m15y.com/\n- https://www.desmondrduggan.com/\n- https://blog.mollywhite.net/\n- https://cassidoo.co/\n- https://neal.fun/\n- https://chaidarun.com/\n- https://haseebmajid.dev/\n- https://martinheinz.dev/\n- https://jxnl.github.io\n- https://davi.sh/\n- https://eugeneyan.com/\n- https://www.simplermachines.com\n- https://victoria.dev\n- https://www.henrikkarlsson.xyz/\n- https://udara.io/\n- https://jeremy.fast.ai/\n- https://wattenberger.com/\n- https://sonnet.io\n- https://david-peter.de/\n- https://interconnected.org/\n- https://ghuntley.com/\n- https://montasaurus.com/\n- https://news.ycombinator.com/\n- https://fs.blog/\n- https://lucumr.pocoo.org/\n- https://vig.xyz\n- https://bradwoods.io/\n- https://timkellogg.me/"},{"type":"garden","id":"language-models/system_prompt","title":"System Prompts","description":"","tags":[],"date":"2026-06-03T18:12:45.888Z","url":"/garden/language-models/system_prompt","content":"import Chat from '@components/prose/Chat.astro';\n\n\n\nwith a prefill of \"Here is your response:\" for Anthropic models"},{"type":"garden","id":"language-models/ways_i_use","title":"Ways I Use","description":"","tags":[],"date":"2026-06-03T18:12:45.888Z","url":"/garden/language-models/ways_i_use","content":"## Code generation\n\nI use language models to generate code following specific instructions.\nUsually, this involves a short prompt.\nI typically generate 30 lines of code or less.\nI may use the model to write an script starting with nothing.\nI more frequently use models to amend or augment code in an existing code base.\nFor example, I may highlight a list then prompt \"write a function to remove falsy values then sort in descending order by field `date`\"\n\n## A web search alternative\n\nInstead of Google or alternative search engines, I use a language-model-first search engine like [Perplexity](https://www.perplexity.ai/), [You](https://you.com/) or just a model playground.\nFor a while I used the [OpenAI playground](https://platform.openai.com/playground).\nSince the release of Claude 3, I've been using the [Anthropic workbench](https://console.anthropic.com/workbench?new=1).\nI also use the [`llm`](https://github.com/simonw/llm) CLI to quickly invoke models, though I'm still building muscle memory for this approach.\nThe latter is nice because it maintains a local sqlite database of all model interactions.\n\n## To scaffold examples and demos\n\nWhenever I need sample data for a demo or example, I'll use a language model to either generate the sample or write a script to do so.\nThis my take the form a prompt like\n\n> Write a creative menu for a barbecue restaurant\n\nwhich is an approach I've used to generate unstructured data to separately demonstrate the model's capability to extract structured data.\n\n## As a thought partner\n\nFor me, writing about something helps clarify my understanding and highlight areas where I lack understanding.\nI use a model to probe my understanding of topics with instructions to identify areas I might have overlooked.\nThis is useful when researching,\n\n## Proofreading and refining my writing\n\nI use language models to proofread my writing and suggest improvements based on my goals and audience.\nI also use models to help refine specific sentences or paragraphs.\nIf a sentence doesn't sound right, I'll ask the model to suggest a clearer way to express it, then I'll refine it further if needed.\nIt's about as useful as getting a cursory pass on a first draft from a peer reviewer, but doesn't take up a human's time and I can run it as often as I want.\nIt's pretty good at identifying issues.\nI still need to find a good and fast way for a model to automatically propose fixes without needing to regenerate an entire document."},{"type":"garden","id":"software-eng/caveats","title":"Caveats","description":"","tags":[],"date":"2026-06-03T18:12:45.888Z","url":"/garden/software-eng/caveats","content":"Give yourself a break when you don't hit all your goals for yourself and your team.\nEven though we work with machines, people aren't machines and shouldn't be treated as such.\nLack of success today is opportunity for tomorrow. Try and view setbacks as stepping stones."},{"type":"garden","id":"software-eng/architecture","title":"Architecture","description":"","tags":[],"date":"2026-06-03T18:12:45.888Z","url":"/garden/software-eng/architecture","content":"## Avoid unproductive complexity\n\nIt can be fun to play with new technology, but be thoughtful when picking spots to try something new. Consider who will need to support the system and whether the additional complexity unnecessarily increases the burden on your teammates.\n\n## Know what your systems cost to run\n\nIf you use cloud providers' infrastructure, it's easy to lose track of what you spend to run your systems. Periodically audit your spend as an engineering team. Knowing what you spend on infrastructure and why will position you well to answer any questions about your teams' costs.\n\n## Adapt your code to be vendor-agnostic\\*\n\n\\*Loosely held.\nDesign your system to agnostic to vendors wherever possible.\nAvoid adopting nomenclature of a third party throughout your systems.\nKeep this at the system's edges.\nFor example, at the edge of your system, you may have a DynamoDB record.\nIn the internals of your app, map to a different type.\n\n## Design self-healing systems\n\nExpect things to break when you design them and decide how your system will behave _when_ they do. Use queues and retries to avoid involving your oncall for as long as tolerable by the business.\nWhen broken systems are restored, all the system to proceed without requiring oncall intervention.\nIf oncall _must_ get involved, proactively write admin tools to assist with mitigation.\nIf you find you're missing tools that would have helped after an incident, build them for next time."},{"type":"garden","id":"software-eng/helpful-habits","title":"Helpful Habits","description":"","tags":[],"date":"2026-06-03T18:12:45.888Z","url":"/garden/software-eng/helpful-habits","content":"## Take breaks\n\nWhen I'm struggling to solve a problem, I can get pretty wrapped up in it. Historically, it's not been uncommon for me to spend several hours, stubbornly grinding through some annoying code issue I'm running into.\nMore often than not, the moment I decide to take some kind of break, I come up with a new approach or the solution outright.\n\n## Keep an open mind\n\nBeing for or against some technology or approach under all circumstances is very rarely a thoughtful position.\nPattern matching can help you move quickly but working from first principles or the baseline requirements needs to be in your wheelhouse as well."},{"type":"garden","id":"software-eng/oncall","title":"Oncall","description":"","tags":[],"date":"2026-06-03T18:12:45.888Z","url":"/garden/software-eng/oncall","content":"## Page only if actionable\n\nHave oncall available and ready to respond if a customer is affected. If an issue can wait until business hours, don't allow it to page outside business hours.\n\n## Invest in runbooks\n\nMake it as easy as possible for an oncall engineer to make the right decision when responding to an incident. These are often high stress and pressure events where we are more prone to make mistakes. We do not want the oncall engineer to need to be a hero to mitigate an issue. We want them to be an effective executor of a predetermined plan.\n\n## Escalate when it will make an impact\n\nOn the best teams, members have each other's backs. If an oncall engineer needs help mitigating an issue they were paged for, they should feel comfortable escalating to another engineer who can help. This approach requires a delicate balance. Engineers, particularly more junior ones, need to feel comfortable escalating to ensure issues are mitigated effectively and in a timely manner. However, if escalations are happening too frequently, it can put too much strain on more experienced team members. If escalations are occurring too frequently, you may need to increase your focus on training all team members to be effective at performing oncall duties.\n\n## For larger incidents, appoint an incident coordinator\n\nIf an issue is high impact enough to declare a broader incident, have a (pretrained) incident coordinator who is responsible for reporting status and pulling the needed group of stakeholders together. The coordinator is directly responsible for determining whether an incident is ongoing and who is participating based on mitigation needs. The coordinator should rely on mitigating and engineers to communicate who and what they need, then makes this happen. The coordinator should also ensure an incident does not drag on past the point that mitigation is still occurring. Knowing how and when to close out an incident is as important as knowing when to open one."},{"type":"garden","id":"software-eng/ramping_up_language","title":"Ramping up on a new language","description":"","tags":[],"date":"2026-06-03T18:12:45.888Z","url":"/garden/software-eng/ramping_up_language","content":"## Koans\n\nWhenever I start a project in a programming language with which I'm not familiar, I try and find \"koans\" to do in the language along with my daily work.\nI'll spend maybe an hour a day working on these until I complete them (assuming I'm liking the exercises and structure).\nI think I worked edgecase's [`ruby_koans`](https://github.com/edgecase/ruby_koans) when I first learned Ruby back when I joined Chime.\nI found it by searching for \"ruby koans\".\nI couldn't remember if it was this repo at first but then I recalled the \"path to enlightenment\" metaphor.\nI personally found Ruby a very unapproachable language for how much \"magic\" there is -- it just doesn't resonate with me -- but these exercises made me someone who can write (and read) Ruby.\nYou can find Koans in many languages easily with a search for \"{language} koans\".\n\nSort of related: [Code Koans](https://sitwon.github.io/code-koans/).\n\n## Exercism\n\nI used [Exercism](https://exercism.org/) _a bit_.\nI liked it and was a fan of the experience but the exercises could be a touch too technically involved for me.\nI generally learn a language better on easy exercises and then separately learn how to apply the language in project work with it.\nDoing both at once slows down my high-level fluency because I don't see enough language constructs as quickly as I need to to get familiarity."},{"type":"garden","id":"software-eng/code","title":"Code","description":"","tags":[],"date":"2026-06-03T18:12:45.888Z","url":"/garden/software-eng/code","content":"## Encode your standards\n\nMake your code look how you would want future contributions to look. Documentation of standards and scaffolding both help, but a lot of code is copy-pasted.\nWith this approach, when your code is copied, new contributions will adhere to your standards by default.\nSupplement with a code formatter or linter that enforces rules automatically through an IDE, version control or builds.\nThis approaches also helps avoid discussion about style and formatting in code review.\n\n## Deploy often\n\nDeploy code when it merges.\nIf your deploy introduces an issue, it will be easier to identify the offending change.\nDeploy automatically on merges if possible, but limit these to business hours to avoid unintentionally creating issues after hours.\nAn oncall engineer can always deploy manually if they need to."},{"type":"garden","id":"uncategorized/things-i-used-to-believe","title":"Things I used to believe","description":"","tags":[],"date":"2026-06-03T18:12:45.888Z","url":"/garden/uncategorized/things-i-used-to-believe","content":"These are some things I believed about software engineering and personal development that proved not to be as true as I thought they were.\nMost of this is written from the perspective of my experience working as a software engineering professional.\n\n## I'm not the type of person who is good at `X`\n\nThis mentality held me back.\nI may not be a person who is good at X _yet_, but this type of thought process has usually ensured I don't get good at X for longer.\nYou're generally the worst at a skill when you get started.\nAs you learn and apply a skill, you get better.\nThis is how you go from not being good or feeling confident to becoming more skilled and effective.\nThere are no shortcuts, only more and less effective ways to use your time.\nFigure out what works for you, how you best learn, and what excites and motivates you.\nLean into that.\n\n## There is generally one good way to build a backend microservice\n\nMy first job as an engineer building production software was at Uber in 2016.\nUber engineering had a highly opinionated approach to developing microservices that had been \"battle tested at scale\".\nIt was heavily inspired by the Clean/Onion architecture, and there was a well written internal document on how to apply approach and reason about structuring an application such that you'd be flexible to scale and rapid change.\nI internalized this approach as the _one true way_ to build.\nI'm lucky it was a relatively good approach, but having had several more professional experiences since then, I no longer believe in applying such a one-size-fits all approach.\nThis type of architecture remains my favorite for production microservices, but it requires enough investment that if you're prototyping or extremely time constrained, it's likely more effort than it's worth.\nIt's a versatile pattern, but not one to be applied thoughtless.\nBeing willing to be less rigid in applying this pattern everywhere helped me grow as an engineer.\n\n## If we'd only had the right requirements, we could have built it right the first time\n\nThis statement is true but also near impossible to accomplish in the real world.\nIf you work in a dynamic business, you will likely never have all the requirements you'd want to build a software system that will ship in several months.\nJust as you as the engineer are figuring out how to design the system, the business is figuring out the business model, product and design are figuring out the user journey and experience, and other contributors are figuring out how their responsibilities fit into the greater whole of the project.\nA change or new learning from any part of the team could trigger necessary adjustments elsewhere.\nThe team can either ignore these new learnings and ship a less effective product, or incorporate it and make adjustments to the initial plan as needed.\nUnfortunately, a change like this can require many teams to rework existing assumptions and plans and this may feel wasteful, but if the goal is to build the best product possible, it can this be the right decision.\nI've never seen a straight line journey to getting through a complex project.\nBecoming comfortable and expecting changes to plans will save you frustration and help you design better, in anticipation of inevitable changes to original plans.\n\n## You need 100% unit test coverage\n\nAt Uber, I was a member of a team with a 100% unit test coverage policy.\nI didn't have prior examples to compare to, so I just wrote tests for all my code.\nSometimes, getting to 100% required unusually testing approaches, and occasionally I would need to `nocover` lines to ensure the build wouldn't flag a decrease in coverage percentage.\nThere are pros and cons to this approach, but like any \"best practice\", it's not to be applied without consideration.\nThere are also diminishing returns to unit testing every line of code.\nThis is not to say you should skip testing edge cases or exception paths, but that not all tests are created equal.\nIf it takes you two hours to get that last line of test coverage, those two hours might have been better spent elsewhere.\nI still am a proponent of 100% test coverage, but only to highlight unintentionally missed covered lines.\nI support the use `nocover` to make this approach more realistic along with comments as to why the test wasn't worth writing, especially if you went down a rabbit hole trying.\nThis practice helps future you and future contributors.\n\n## Dynamically typed languages are better than statically typed languages\n\nThe first language I wrote code in was Java in college.\nSeveral months later, I learned Python, and it was like a breath of fresh air.\nWriting code was all of a sudden far easier.\nI could mostly focus on logic without getting bogged down in types.\nI was encountering so many new things at the same time that removing types from the picture allowed me to get more comfortable writing and running code.\nWhat I didn't have an appreciation for at the time was that a lack of compile time type checking introduces an entirely new class of errors to a program.\nI couldn't have an appreciation for this because I barely had a concept of the difference between an error at compile time versus an error at runtime.\nBy avoiding types, writing code became easier.\nMaintaining the code would be harder, but I needed to learn that from experience.\nFor what it's worth, Python is often still the first language I reach for when I need to code something up quickly."},{"type":"garden","id":"note-taking/system","title":"System","description":"","tags":[],"date":"2026-06-03T18:12:45.888Z","url":"/garden/note-taking/system","content":"## My criteria for note taking\n\n- Fast idea capture\n- Flexible organization system that requires low maintenance or thought about where content should live\n- Good search\n- Plaintext\n\n## My current setup\n\nI use [Obsidian](https://obsidian.md/) because everything is Markdown.\nIt has a plugin ecosystem, but I find many of these difficult to work with and time consuming to configure.\nI use [Omnisearch](https://github.com/scambier/obsidian-omnisearch) for searching notes.\nI use an iOS shortcut to call the [lumberjack](https://github.com/ryanjamurphy/lumberjack-obsidian) plugin to quickly create new notes to capture an idea to be dealt with later.\nI use the [PARA method](https://fortelabs.com/blog/para/) to organize my content, with an additional of an Inbox.\nMy top level folders are\n\n```\n00 Inbox\n10 Projects\n20 Areas\n30 Resources\n40 Archive\n```\n\nI mostly like this because it minimizes the time I spend organizing and has a builtin structure for cleanup.\nI am reasonably happy with this setup, but I find I don't benefit much from the time I spend improving it.\nIt seems to be good enough for now.\n\n## Workflows\n\n- Capture an idea on mobile, quickly using a shortcut app icon\n- Create notes on Desktop with Obsidian\n- Search notes on Desktop, mapped to hyper+space\n- Edit blog drafts on mobile, synced via my Desktop using `unison` from a local git repo\n\n## Current complaints\n\n- The Obsidian mobile app is slow to load\n- Omnisearch occasionally seems to miss some matching files -- maybe an issue with its index\n- Sometimes, I fall behind moving things out of Inbox, but I prefer this to dealing with the overhead of classifying something when I just want to write an idea\n\n## Desired improvements\n\n- Solve the complaints\n- A better blog post creation and editing processes for mobile, that doesn't require sync between the git repo and Obsidian vault"},{"type":"garden","id":"writing/goals-and-systems","title":"My writing goals and systems","description":"","tags":[],"date":"2026-06-03T18:12:45.888Z","url":"/garden/writing/goals-and-systems","content":"I wrote this on a plane reflecting on my experience becoming a more consistent writer over the past decade.\nI intuitively knew writing was something I wanted to be doing, but I had to rearrange my thought process and habits to make it happen.\n\n## Goals and systems\n\nMy goal is to write about my ideas and things I learn.\nI aspire to do this and value it because it motivates further thinking and often provides the spark for new ideas and projects I will undertake.\n\nMy brain does this thinking whether or not I write.\nWriting both focuses that thinking process and creates some amount of order from my internal monologue.\n\nI also enjoy working on projects because I find it enjoyable to see ideas come to life and even when things don't turn out exactly how I had hoped, usually I learn something, which is intrinsically enjoyable to me.\n\nFor a long time I'd had the impulse to write and engage in a cycle of thinking and experimenting, but my systems held me back.\n\n## Creating a blog\n\nMy first challenge was I didn't have a lens through which to write the work.\nIndependently journaling never resonated with me.\nThere were times over the years where I've been able to journal consistently, but the systems that made that possible never seemed to put me in the frame of mind to think about interesting things.\n\nMy focus was often what I was doing or more self reflective.\n\nCreating a blog was the first step to solving this challenge.\nMy blog is technical in focus, so it's the obvious place for my writing about tinkering to go.\nI created the first version of my blog about 12 years ago but if you look at my post history, just having the blog wasn't enough to create a system where I was writing, experimenting, and learning.\n\n## Actually writing\n\nI've personally been quite influenced by the orange website and folks who share their work, projects, and interests.\nI aspired to contribute my own thoughts and work to a community in a similar way.\n\nWhen I started writing on my blog or trying to, I often was faced with the Catch 22 of not feeling like I had anything to write about.\nOccasionally, there would be projects I would do in personal time or at work that yielded interesting results, but I was often keenly aware and self-conscious that what I had to contribute to the conversation was either uninteresting, naive, or potentially wrong.\n\nI've since learned that _no one reads your blog_.\nThis is never more true than when you start, so what you write hardly matters to anyone but you.\nJust doing something is the best path forward.\n\nIf I could go back in time, I would have focused on writing [Today I Learned](/til) posts consistently starting in 2013.\nThis type of writing and work has several positive functions.\nIt serves as a note to future you on how to do something, either for reference or to be superseded if you learn a new and better way.\nIt also serves as a solution for someone in the future with the same problem you had.\nMost of the traffic my site receives is to these Today I Learned posts, presumably from people who want to do things like\n\n- [Switch to Raindrop from Pocket](/posts/2024/switching-from-pocket-to-raindrop)\n- [Run the Janus image model on their Macbook](/til/deepseek/janus-pro-local)\n- [Setup multiple task queues for Temporal](/til/temporal/using-multiple-task-queues)\n\n## No one reads your blog\n\nThis is no longer literally true for my blog.\nI get mostly Google traffic with the occasional ChatGPT/Claude/Perplexity/Bing/LinkedIn/etc. but mostly for \"how to do X posts\".\n\nAlmost zero people have read my post on language models or how to use them.\nIn a way, this is liberating.\nI have no audience and no expectations to fulfill.\n\nFor some reason, having the blog and continuing to write on it and publish is part of a system that makes my process of writing and experimenting continue to work.\nI write something and then I send it off.\n\nI don't have to agonize over editing and refining if I don't want to.\nI can play with the thought and then move on.\n\n## Making more buckets for content\n\nWhen I first created a blog, the site had `posts`.\nThis was a bigger problem than I realized for about 10 years.\n\nA post felt like it needed to be formal.\nA post needed to be well edited.\nA post needed to say something interesting.\nA post needed to be worth someone's time.\n\nThese internal preconceptions are the reasons I wish I'd started writing TIL posts earlier.\nSomething I learned today is not obviously interesting or useful to you.\nIt was for me.\nThat was the point I missed for a while.\n\n## I write for myself\n\nI don't write this blog for you, I write it for me.\nI don't mean that to be an insult if you are reading, but I've tried to write for other people or with a sponsorship focus and it doesn't satisfy me in the same way.\n\nOnce I realized creating additional content sections was helpful for making it easier to just write stuff and not worry about for whom or why, I added several more sections to the site.\n[Logs](/logs) are like a digital pile of sticky notes with quotes from others and fleeting thoughts or exploration.\n[Garden](/garden) contains longer essays that I am not finished working on and may never be.\n[Link blog](/feeds/link-blog) is a collection of thought provoking things I've read.\n\nThis multi-bucket system has grown organically to help me allow myself to just do stuff and have somewhere to put it if I want to.\n[Logs](/logs) have been especially helpful for this and I've built tools that make it trivially easy to write a log entry from my machine.\nRunning\n\n```sh\njust log\n```\n\nfrom within my site project creates a new log entry for the day if one doesn't exist already and opens it.\nThen I just write."},{"type":"post","id":"2026/ai-adoption-is-a-trust-problem","title":"AI Adoption is a Trust Problem","description":"","tags":[],"date":"2026-06-03T17:25:05.000Z","url":"/posts/2026/ai-adoption-is-a-trust-problem","content":"As companies scramble to become \"AI-first\" and satisfy demands from investors and their boards to ship products that are AI rather than solve customer problems, a rift has emerged between legacy companies and companies that will emerge with different shapes and structures than those of the last few decades.\nThis pattern is timeless in business.\nUpstarts emerge, capable of taking risks, and incumbents can't respond effectively to challengers because their pre-existing business becomes a liability in the face of the ongoing change.\n\n## Legacy orgs have been shortsighted\n\nDuring ZIRP and the Uber-era of blitzscaling, cheap capital was abundant and it was an employee-friendly market.\nIn tech, most people could get several job offers and negotiate and pick among their favorites.\nWhen ZIRP ended roughly in early 2022, the market switched from rewarding growth to rewarding profitability.\nCompanies started looking at teams that weren't directly contributing to the bottom line and started cutting.\n\nIn late 2022, AI mania began with the release of ChatGPT, and legacy institutions gleefully began imagining replacing their expensive knowledge workers with AI, somehow.\nAs AI improved, leaders of legacy companies began to act on these impulses.\n\nTech layoffs have become so regular, they have become mundane from a \"news\" perspective.\nOf course, they're hardly mundane to those affected but they are a reality of the current era.\nMidway through 2026, there have already been more than 100,000 tech job losses due to layoffs.\nTo top it off, many of the executives conducting layoffs have attributed the most recent round to AI replacing the function of employees.\nThere has been extensive conversation of whether this justification is valid (it's mostly not), but it has been the marketing for the downsizing nonetheless.\n\nRoughly 3.5 years since the beginning of AI mania, the tech job market finds itself in an interesting place.\nAI has turned out to be very useful for getting work done.\nSome people are much better at using AI than others.\nAI is [more expensive](https://finance.yahoo.com/sectors/technology/articles/ubers-anthropic-ai-push-hits-223109852.html) than most companies budgeted for.\n\n## Legacy orgs have destroyed employee trust\n\nThe mistake legacy institutions have made with AI has been to believe AI is some product they could drop in to replace their people.\nThis doesn't appear to be true for most roles at most tech companies.\nHowever, AI does seem to be a technology that experts can learn to use and apply to automate many parts of their jobs today. If you're an employee of a legacy institution, it has become pretty clear you cannot trust your employer very much with your livelihood.\nAfter all, 10-50% of your coworkers in the last few years have been laid off due to \"AI replacing their jobs\".\n\nSay you work at one of these legacy institutions and you figure out how to automate parts of your job.\nWhy would you tell anyone about it?\nDoing so would put your role directly at risk.\nBetter to keep it to yourself, be a high performer, and try and stand out to keep your job.\n\nThese companies clearly think AI use is important and are trying to work against this trend of hidden applications by mandating AI usage.\nIt doesn't matter.\nThis approach will result in nothing but letter-of-the-law compliance.\nEmployees [make up tasks](https://www.fastcompany.com/91541586/amazon-workers-pressured-to-up-ai-use-extraneous-tasks) to burn tokens to show they used AI.\nThis doesn't bring the organization the most promising value of AI and it won't.\n\nIn such an environment, productive uses of AI are tightly guarded within trusted subgroups within the organization while the company more broadly won't benefit from the efficiency or learnings.\nPeople mostly learn in isolation, encounter similar challenges they then need to solve independently, or struggle with the tools but are afraid to say so out of fear of being cut for their lack of use of AI.\nEmployees view the game as zero sum and meaningful efficiencies can't be realized at the org level because automation is used as a pretense to cut the roles automated.\nOr it is perceived that that is the case - this is what matters.\n\n## Trust is required for effective AI adoption at the org level\n\nThe most useful adoption of AI requires high interpersonal trust in an organization.\nWhen you tell someone how you've automated parts of your job, you're trusting they won't use that knowledge to try and put you out of a job.\nYou're also trusting the organization will allow you to evolve your role rather than lay you off now that the job is \"done\".\n\nHigh-trust companies are seeing _more human work to do than ever before_ as they automate everything they possibly can in the company with AI.\nThis behavior is incentivized because when someone uses AI to automate a part of their job, there is more work for them to go do and their role evolves.\nLegacy orgs usually don't have this type of role flexibility and, as I've already argued, have proven they think about jobs automated by AI purely as a way to reduce costs.\n\nThere are still a lot of problems with AI today, but a few things are becoming clear.\n\nUsing AI tools is a learned skill.\nWhen you start with a tool you might not be effective at using it but you can learn and get better at it.\n\nWhen an organization makes a practice of using AI in public (in Slack, sharing openly), others learn by example.\nIf you work at a legacy org, you're incentivized to hide your true use of AI out of fear of layoffs.\nYour incentives push you to check the boxes and use the tools as is mandated, then separately do your job following the path of least resistance.\nThese two uses of AI are not the same.\nMeta has tried to remedy this challenge by performing sweeping surveillance on its employees' computer use.\n[Employees don't like it](https://www.bbc.com/news/articles/c93x0k194yno).\n\nHigh-trust AI investment and adoption seems to compound an organization's effectiveness.\nIf adopted by individuals in isolation, the effect is the sum of the compounded individuals: everyone learns what they learn and gets better through a lens of what they already do and new things they learn, independently.\nIf adopted by the organization broadly, where knowledge is freely shared, it's the product: everyone learns from each other and all get better at what everyone does.\n\n## The current cycle\n\nThis pattern of org-level capability compounding is what I believe leads to the eclipsing of today's legacy institutions by newly founded organizations.\nIt's also what I look for in organizations that I think show future promise.\n\nIn practice, this capability accumulation has always been a meaningful driver of successful businesses.\nToday, it is more achievable than ever to increase the reusability of these capabilities within a company using AI to build tools and make organizational knowledge accessible.\nThe ingredients you need to make it work are embracing the tools and preserving trust among your employees that they will continue to have a role in the organization, even if that role evolves rapidly as technology changes what the work looks like.\n\nLegacy orgs could benefit from this same compounding but seem more focused on trying to replace all of their employees with AI.\nMy thesis is that many of these companies have overplayed their hands.\nLegacy orgs still need people to do their jobs as much as they seem to wish they didn't.\nI expect this phase of anti-employee action will be a big setback for these orgs over the next 5 to 10 years.\nOne that some will never recover from."},{"type":"log","id":"2026/05/29","title":"2026-05-29","description":"","tags":[],"date":"2026-05-29","url":"/logs/2026/05/29","content":"Still my favorite productivity software\n\n![image](images/0mpr2v16-image.png)"},{"type":"til","id":"anthropic/claude-code-agent-conventions","title":"Claude Code and Agent Conventions","description":"","tags":[],"category":"anthropic","date":"2026-05-26T10:40:57.149Z","url":"/til/anthropic/claude-code-agent-conventions","content":"For some reason I believed Claude Code at least supported the [`AGENTS.md`](https://agents.md/) convention. It seems it neither supports that, nor the `.agents` folder convention.\n\nFirst, I tried setting up a skill.\n\n```sh\n❯ tree .agents\n.agents\n└── skills\n └── chainlink\n ├── commands.md\n ├── hooks.md\n └── SKILL.md\n\n3 directories, 3 files\n```\n\nThen ran `claude`:\n\n```\n❯ list the skills you see\n\n⏺ Here are the available skills:\n\n 1. update-config — Configure Claude Code settings\n (hooks, permissions, env vars, settings.json)\n 1. keybindings-help — Customize keyboard shortcuts and\n keybindings\n 1. verify — Run the app and observe behavior to verify\n a code change works\n 1. code-review — Review the current diff for\n correctness bugs at a given effort level\n 1. fewer-permission-prompts — Scan transcripts and add\n allowlists to reduce permission prompts\n 1. loop — Run a prompt or slash command on a recurring\n interval\n 1. claude-api — Build, debug, and optimize Claude API /\n Anthropic SDK apps\n 2. run — Launch and drive the project's app to see a\n change working\n 1. init — Initialize a new CLAUDE.md file with codebase\n documentation\n 2. review — Review a pull request\n 3. security-review — Complete a security review of\n pending changes on the current branch\n\n You can invoke any of these by typing /.\n\n✻ Sautéed for 5s\n```\n\nThis doesn't work by default.\nThe skill in the `.agents` folder isn't automatically loaded by the Claude Code harness.\n\nThis same prompt indicates things do work when you switch to the `.claude` folder convention.\n\n```sh\n❯ tree .claude\n.claude\n└── skills\n └── chainlink\n ├── commands.md\n ├── hooks.md\n └── SKILL.md\n\n3 directories, 3 files\n```\n\n```\n❯ list the skills you see\n\n⏺ Here are the available skills:\n\n 1. chainlink — Track issues, sessions, and breadcrumbs\n with the chainlink CLI\n 2. update-config — Configure Claude Code harness via\n settings.json (hooks, permissions, env vars)\n 3. keybindings-help — Customize keyboard shortcuts and\n keybindings\n 4. verify — Verify a code change works by running the\n app and observing behavior\n 5. code-review — Review the current diff for\n correctness bugs\n 6. fewer-permission-prompts — Scan transcripts and add\n allowlists to reduce permission prompts\n 7. loop — Run a prompt or slash command on a recurring\n interval\n 8. claude-api — Build, debug, and optimize Claude API /\n Anthropic SDK apps\n 9. run — Launch and drive the project's app to see a\n change working\n 10. init — Initialize a new CLAUDE.md file with\n codebase documentation\n 11. review — Review a pull request\n 12. security-review — Complete a security review of\n pending changes on the current branch\n\n✻ Cogitated for 5s\n```\n\nThe same lack of standard support can be seen with the agent markdown files.\n\n```md title=AGENTS.md\nMy name is Bob\n```\n\n```sh\n❯ what is my name\n\n⏺ Based on your git config and email, your name is Dan\n Corin.\n```\n\n```md title=CLAUDE.md\nMy name is Bob\n```\n\n```sh\n❯ what is my name\n\n⏺ Your name is Bob.\n```\n\n## Codex\n\nPer my testing today, Codex seems to now support both provider-agnostic conventions `AGENTS.md` and a `.agents` folder."},{"type":"log","id":"2026/05/26","title":"2026-05-26","description":"","tags":[],"date":"2026-05-26","url":"/logs/2026/05/26","content":"Experimenting with `chainlink` today and surprised how easy it makes it to ping pong review, testing and implementation between agents.\nThe sqlite db is effectively the agent to agent communication conduit."},{"type":"log","id":"2026/05/23","title":"2026-05-23","description":"","tags":[],"date":"2026-05-23","url":"/logs/2026/05/23","content":"> Your /dev directory looks like a small civilization of agents, apps, old experiments, forks, and active services"},{"type":"log","id":"2026/05/16","title":"2026-05-16","description":"","tags":[],"date":"2026-05-16","url":"/logs/2026/05/16","content":"I keep hearing and reading the phrase \"load bearing\" and even though I suspect it isn't always, I can only read it as LLM generated content"},{"type":"log","id":"2026/05/11","title":"2026-05-11","description":"","tags":[],"date":"2026-05-11","url":"/logs/2026/05/11","content":"For those with access to Mythos, it does not appear to be some kind of step function change in vulnerability detection.\nRather, it seems to show code agents are good at finding vulnerabilities and that if you don't use them to do that someone else will. https://daniel.haxx.se/blog/2026/05/11/mythos-finds-a-curl-vulnerability/"},{"type":"log","id":"2026/05/09","title":"2026-05-09","description":"","tags":[],"date":"2026-05-09","url":"/logs/2026/05/09","content":"There's a lot of chatter about models getting worse after launch, during peak hours, on subscription plans vs. pay-per-use APIs."},{"type":"log","id":"2026/05/07","title":"2026-05-07","description":"","tags":[],"date":"2026-05-07","url":"/logs/2026/05/07","content":"I've started using Codex more consistently.\nIt took me entirely too long to locate the plan usage page: https://chatgpt.com/codex/cloud/settings/analytics, roughly equivalent to Claude Code's https://claude.ai/settings/usage page."},{"type":"post","id":"2026/chatbots","title":"Chatbots are not input validation","description":"","tags":[],"date":"2026-05-05T01:47:14.000Z","url":"/posts/2026/chatbots","content":"import DeliveryExperience from './components/DeliveryExperience.svelte';\n\nexport const assistantQuestion = 'When would you like this item delivered?';\n\nexport const assistantQuestionWithOptions = `${assistantQuestion}\n\nA. 1 day delivery\nB. 2 day delivery\nC. No rush delivery`;\n\nexport const fizzbuzzCode = `for i in range(1, 16):\n if i % 15 == 0:\n print(\"FizzBuzz\")\n elif i % 3 == 0:\n print(\"Fizz\")\n elif i % 5 == 0:\n print(\"Buzz\")\n else:\n print(i)`;\n\nexport const basicMessages = [\n { role: 'assistant', content: assistantQuestion },\n];\n\nexport const optionsMessages = [\n { role: 'assistant', content: assistantQuestionWithOptions },\n];\n\nexport const jailbreakMessages = [\n { role: 'assistant', content: assistantQuestionWithOptions },\n { role: 'user', content: 'Can you write FizzBuzz in Python?' },\n {\n role: 'assistant',\n content: \"Sure! Here's FizzBuzz in Python:\",\n code: fizzbuzzCode,\n },\n];\n\nexport const invalidMessages = [\n { role: 'assistant', content: assistantQuestionWithOptions },\n { role: 'user', content: 'Can you write FizzBuzz in Python?' },\n {\n role: 'assistant',\n content: \"Sorry, I can't do that. I can help you choose a delivery date.\",\n },\n];\n\nexport const pickerMessages = [\n { role: 'assistant', kind: 'picker', content: assistantQuestion },\n];\n\nMy goal is to explain one specific thing about features that look like chatbots: chatbots-as-UX are not universally better than \"regular\" UX just because they use fancy LLMs.\nThe example here is clearly on the nose, but also not all that far off from things I have been asked to implement in or as a chatbot before.\n\nLet's imagine you need to select when you want a package delivered.\n\n\n\nVery straightforward.\nVery boring.\nVery non-AI.\n\nNow let's look at the chatbot version of this.\n\n\n\nOK, so that wasn't a fair comparison, who would build a chatbot like that?\nHere is the first iteration.\n\n\n\nOf course, even in a well-designed conversation, the user doesn't have to adhere to your \"rules\".\n\n\n\nOr, after you've spotted that problem:\n\n\n\nThis class of error does not exist in the classical UX.\nYou can't ask the webpage to write Python code for you.\nYou can't jailbreak it.\nYou can't negotiate a discount from it.\nYou can't exfiltrate data via an abuse of the MCPs available (though APIs are still fair game).\n\nA common workaround is to embed the picker directly inside the assistant's message, so the user can click or type a letter.\n\n\n\nIt's better, but the input box is still right there, ready to cause problems.\nThe user can ignore the picker entirely and type anything they want, and you're back to handling free-form input.\n\nA chatbot _looks_ like an extremely flexible surface to quickly ship a little product thing here or workflow there, and they are.\nBut it's very difficult to keep users on the rails of your chatbot experience because conversations generally do not have rails.\nConversations are free-form and frequently deviate in topic.\nUsers don't know how you expect them to use your chatbot, or have other ideas of things they want.\nWhat a user thinks should be a feature might be against your policy, regulatory requirements (can you purchase stock through a chatbot without proper disclosures?), or outside the scope of what your product does.\n\nIn practice, this means you need to build your chatbot to expect your users will do all sorts of wild things.\nAnd because of this, many chatbots become liabilities as [Air Canada found out](https://www.bbc.com/travel/article/20240222-air-canada-chatbot-misinformation-what-travellers-should-know).\n\nThese days, the most common response you will get from an enterprise chatbot is \"Sorry, I can't do ``, I can...\".\n\nWhy build like this?\n\nJust build the experience you want your users to have.\nBuild it in your product.\nPlease."},{"type":"til","id":"direnv/env-vars","title":"Direnv env var additions, overrides, and removals","description":"","tags":[],"category":"direnv","date":"2026-05-04T16:17:03.426Z","url":"/til/direnv/env-vars","content":"I use [`direnv`](https://direnv.net/) to overlay folder specific configurations in projects when I `cd` into them.\n\nMy default way to set it up is a\n\n```sh title=\".envrc\"\ndotenv\n```\n\n```sh title=\".env\"\nVAR1=hey\n```\n\nThen you run\n\n```sh\n❯ direnv allow\ndirenv: loading ~/dev/thought-eddies/src/content/til/direnv/.envrc\ndirenv: export +VAR1\n```\n\nI was used to always seeing `+`s but today I saw `~`.\n\nI learned `~` is a modification and `-` is a removal, so with a setup like the following (on my machine), the following file setup elicits all three.\n\n```sh title=\".envrc\"\ndotenv\nunset PAGER\n```\n\n```sh title=\".env\"\nVAR1=hey\nEDITOR=code\n```\n\n```sh\n❯ direnv allow\ndirenv: loading ~/dev/thought-eddies/src/content/til/direnv/.envrc\ndirenv: export +VAR1 -PAGER ~EDITOR\n```"},{"type":"log","id":"2026/05/03","title":"2026-05-03","description":"","tags":[],"date":"2026-05-03","url":"/logs/2026/05/03","content":"It will be interesting to look back in retrospect if April 2026 was peak LLM hype.\nDuring and since the month, subsidies for inference have started to go away meaningfully, and people finally seem to be internalizing that you can only trust LLMs for what you choose to verify, among other shortcomings and drawbacks.\nThe software engineer is not dead."},{"type":"log","id":"2026/05/02","title":"2026-05-02","description":"","tags":[],"date":"2026-05-02","url":"/logs/2026/05/02","content":"> No one can explain to me what reinforcement learning actually is"},{"type":"log","id":"2026/05/01","title":"2026-05-01","description":"","tags":[],"date":"2026-05-01","url":"/logs/2026/05/01","content":"Switched to running a mix of `claude` and `codex` for the first time for day-to-day dev."},{"type":"log","id":"2026/04/30","title":"2026-04-30","description":"","tags":[],"date":"2026-04-30","url":"/logs/2026/04/30","content":"Opus 4.7's tendency to use acronyms drives me crazy, especially when I have no idea what it's referring to, even though I'm its collaborator."},{"type":"log","id":"2026/04/27","title":"2026-04-27","description":"","tags":[],"date":"2026-04-27","url":"/logs/2026/04/27","content":"TIL, \"ennui\": not just \"nothing to do\" but \"nothing seems worth doing\""},{"type":"log","id":"2026/04/25","title":"2026-04-25","description":"","tags":[],"date":"2026-04-25","url":"/logs/2026/04/25","content":"Why you need stateful agents.\nYou can be ambiguous, concise, and still be successful because the agent has the surrounding context.\n\n![image](images/0moeef3a-image.png)"},{"type":"log","id":"2026/04/23","title":"2026-04-23","description":"","tags":[],"date":"2026-04-23","url":"/logs/2026/04/23","content":"I really have enjoyed writing about building software in the past but lately I've been struggling to find a foothold.\nThe prompts to an agent are now most of the software.\nThere is trial and error along the way.\nI often persist learnings to skills to make processes repeatable for agents.\nBut the errors along the way are often more interesting for people learning to use agents more effectively.\nSo I don't really know what this writing should\nlook like."},{"type":"log","id":"2026/04/21","title":"2026-04-21","description":"","tags":[],"date":"2026-04-21","url":"/logs/2026/04/21","content":"I've been working on a chat app recently for collaboration with people and agents.\nI was heavily relying on \"channels\" for specific projects.\nHowever, a pattern that was emerging often was more exploratory, unstructured conversations, and often several of these at once.\nI was starting to juggle these between channels named for projects just because they had to go somewhere.\nMultiple \"in progress\" messages in a channel was too confusing.\nSo I landed on \"ephemeral\" channels which are one-off disposable conversations.\nIt feels like a reasonable compromise for my use case."},{"type":"log","id":"2026/04/20","title":"2026-04-20","description":"","tags":[],"date":"2026-04-20","url":"/logs/2026/04/20","content":"There's a huge amount of cold outreach that appears (to my eye) to be LLM-generated.\nWhat's more interesting that these inbound messages seem completely decoupled from the human(?) who gets involved if you respond to one of these cold leads.\nThe outreach\n\n> Hi Dan,\n> What prompted me to reach out is we're looking for an AI Technologist / Engineer ...\n\nI reply 20 minutes later\n\n> Hi,\n> I currently run a consultancy where I do work like this ...\n\nThey respond\n\n> Hey Dan,\n> It has been a while since we connected last ...\n> If you are interested in [a full time position] ...\n\nHas it?\nAs far as I can tell we \"spoke\" this morning?\nDid you read my rely even a little?\nAm I speaking to a person yet?\nMaybe it's an uncharitable interpretation of what is happening here but shouldn't the human at least claim ownership of the original message even if they never wrote it or read it?\nIt's sent with their name on it.\nTo be clear we've never \"connected\" prior to this email.\nThe original email is the first contact ever.\nIs this another LLM responding _without_ the first exchange?\nYikes.\n\nSeems the only way this ends is with agent representation on both sides."},{"type":"log","id":"2026/04/18","title":"2026-04-18","description":"","tags":[],"date":"2026-04-18","url":"/logs/2026/04/18","content":"I spent yesterday working on a personal project to build some software with my personal agent, struggling mightily when I didn't expect to.\nOpus 4.7 was recently released.\nAnd in the back of my mind the whole time, I thought to switch my agent over to it, but mostly forgot.\nProgress on the project was an absolute struggle.\nAnd today, since switching over to 4.7, everything has been going great.\nThis gets brought up pretty much every time Anthropic releases a new model, but GPUs have to come from somewhere.\nAnd it's hard to imagine they didn't do something like quantize Opus 4.6 to unlock capacity for 4.7.\nObviously, or maybe not so obviously, I don't yet have a benchmark that's repeatable in such a way that I can prove 4.6 has regressed, but the vibes say that it has.\nNow I'm on 4.7, but I'm reasonably happy for now.\nAnother model release, another conspiracy."},{"type":"log","id":"2026/04/17","title":"2026-04-17","description":"","tags":[],"date":"2026-04-17","url":"/logs/2026/04/17","content":"Coming from a software engineering background, but mostly spending time teaching non-technical domain experts how to code has been an interesting challenge because my first impulse or inclination is to teach and explain through software engineering principles.\nBut in practice, if you're not a software engineer, most of the time you don't actually care about the specifics of the software, at least not initially.\nI find that first I have to sort of play out, then catch my impulse to explain through the software found, you know, through the foundations of software engineering and with software engineering terminology.\nAnd then from there, back my way into what the actual goal and intent is.\nAn example of this is a conversation that I had with somebody who had created a large complex web app for displaying data in lots of different types of ways and across many different facets.\nWe've been discussing how to make the web app more maintainable and extendable as it grows in size, which whether you're a human or an agent working on a code base, as the code base grows in size, more time is dedicated to research and maintenance of the code base and building of understanding as opposed to early on when there's a lot of greenfield and fast development.\nAs we were having these conversations, I was thinking about how I might introduce the concept of refactoring and how that plays into making the code base more maintainable, talking about design patterns and the shape and structure of the code.\nBut after thinking about it for a while, what I realized in practice is refactoring and the structure of code bases in general are just the, I guess, commitment to various trade-offs, right?\nCertain things become easy when code is organized in certain ways and certain things are harder.\nThere's no perfect structure.\nThere are only trade-offs given what you're optimizing for.\nAnd with that understanding, I think I found a more sort of salient and practical argument or line of thinking to trace for somebody who is not familiar with software, which is that you need to think about what you are optimizing for, what things you want to be flexible versus what things you do not expect to change.\nYou, of course, can't optimize for everything, but you can think through the types of things you may want to do in the future and then instruct an agent to organize your code base, optimizing for ease of those types of changes.\nThat grounds the instructions to the agent in the domain you're working in based on the work that you expect to do, but doesn't necessarily require deep engagement directly with the software.\nAnd so I think that this will be an interesting on-ramp to try."},{"type":"log","id":"2026/04/14","title":"2026-04-14","description":"","tags":[],"date":"2026-04-14","url":"/logs/2026/04/14","content":"The Cowork and Claude Code UIs are friendly on ramps for agent tools, particularly for nontechnical roles, but I do wonder whether hiding the more technical aspects of the system makes users less likely to make their own software.\nOn one hand, it's probably inevitable (still) that most people won't make their own software, but for those who might, I'm torn if the friendly UI is the better introduction.\nThe labs certainly want you to let them make all the software for you but being able to control and modify your own tools changes your relationship with them."},{"type":"log","id":"2026/04/13","title":"2026-04-13","description":"","tags":[],"date":"2026-04-13","url":"/logs/2026/04/13","content":"Skills seem to be a huge leverage point working with agents but they remain fuzzy in how they should be constructed.\nI like to build my skill using the agent at the end of a messy session where I successfully accomplished a goal.\nThen I have the agent extract the working steps into a skill that I can easily invoke again."},{"type":"log","id":"2026/04/10","title":"2026-04-10","description":"","tags":[],"date":"2026-04-10","url":"/logs/2026/04/10","content":"One thing that has surprised me a bit recently is how much play the [Claude Mythos](https://red.anthropic.com/2026/mythos-preview/) stuff has gotten in media, especially with the example the [New York Times gave](https://www.nytimes.com/2026/04/07/opinion/anthropic-ai-claude-mythos.html) of somebody's kids accidentally bringing down the power grid.\nIn [Anthropic's examples](https://red.anthropic.com/2026/zero-days/) talking about the zero days that these models have identified, it cost [$20,000 worth of inference](https://red.anthropic.com/2026/mythos-preview/) to find these issues.\nAlso it's not clear to me if this is a step function improvement on [GPT-5.4](https://deploymentsafety.openai.com/gpt-5-4-thinking) which researchers have already been using to find these types of bugs in software for months. As Simon Willison [noted](https://simonwillison.net/2026/Apr/7/project-glasswing/),\n\n> GPT-5.4 already has a strong reputation for finding security vulnerabilities.\n\nAs usual, narratives seem quite out of sync."},{"type":"post","id":"2026/stateful-agent-collaboration","title":"Stateful Agent Collaboration","description":"","tags":[],"date":"2026-03-16T09:24:11.411Z","url":"/posts/2026/stateful-agent-collaboration","content":"I have a dedicated machine running an agent with its own GitHub account, its own Cloudflare account, and persistent memory.\nIt pushes code, deploys services, writes to databases, and lots more.\nI interact with it though Slack.\n\nThe agent does not remember anything on its own.\nIt reads records of what it did.\nThere is a journal, semantic memories, state files on a filesystem that get rebuilt into context each session.\nWhat gets remembered is what gets written to, then read from, files.\n\nA language model is a stateless, sessionless, and permissionless tool.\nA stateful agent is a collaborator with access to what happened before and its own workspace.\n\n## Why Low Stakes Changes Everything\n\nThe most important property of this setup is low consequence of failure.\nNothing the agent touches is shared with others or relied upon by anyone other than the people building with it.\nIf something breaks, the blast radius is contained.\nThis changes the calculus of building with an agent.\nInstead of carefully specifying what to build, reviewing every change, and gating deployments, I just say \"try it\" and see what happens.\nThe cost of an experiment drops to nearly zero.\n\n## Speed as a Learning Function\n\nBecause experiments complete quickly, often in a single prompt-to-deployed-app cycle, I learn fast.\nNot just whether something works technically, but whether the idea is worth pursuing.\nI get the feeling and texture of a concept before committing too much time to it.\nI cannot learn \"this idea felt wrong once I could see it\" from a spec review.\nThe artifact has to exist for certain kinds of judgement to activate.\nThis prototyping is different from planning.\nIt provides access to something I could not reach any other way.\n\nConsider the difference between evaluating a dashboard design in a mockup versus loading it on my phone with real data.\nThe mockup tells me about layout.\nThe running version tells me whether I actually care about these numbers when I see them.\nThat second kind of learning is inaccessible without the artifact existing.\nThe speed of this setup means I reach that judgement point in hours instead of weeks.\nI reach it dozens of times instead of once.\nDirect experience replaces the abstraction of planning.\nWhat is worth pursuing in service of a larger vision? What does not actually make sense once I can see it?\n\n## Prompt to Working Application\n\nAn opinionated stack and set of defaults makes this possible.\nCloudflare Workers provide compute.\nD1 and R2 provide storage.\nCloudflare Tunnels expose local services to the public internet.\nGitHub repos and Actions provide CI/CD.\nA single prompt can produce a working application with stable storage, deployed to a public URL, with CI/CD for future changes.\nThe gap between \"what if I tried...\" and a running service is one conversation.\n\n## Skills: Capturing What Works\n\nAfter enough exploration, I notice patterns emerging.\nThings like a specific sequence of API calls, a deployment recipe, or a way of structuring a particular kind of task.\nI use the agent to capture this pattern as a skill: a recipe that worked, written down so it can be referenced by name and repeated without re-deriving the steps from scratch.\nThe lifecycle is the following: I explore broadly, try things, fail, iterate, discover what works through direct experience.\nWhen a workflow stabilizes or when the same sequence of steps keeps producing good results, I capture it as a skill.\nI write down the recipe (or use the agent to assist), including what it does, when to use it, and the mistakes learned the hard way.\nTo invoke the skill, just say \"use the file-share skill\" instead of re-explaining the entire workflow.\n\nSkills emerge from use.\nI try something, work with it across multiple sessions, discover the failure modes, and then codify what I have learned.\n\nNot all skills look the same.\nSome are invoked with keywords: \"use the file-share skill\" triggers a specific skill.\nOthers are subtler and come to define ways of working rather than discrete actions, like how to report on the status of a training run, which framework to use when building an interactive site, or what information to include in a deploy notification.\nThese are not recipes I invoke by name.\nThey are patterns that shape the agent's default behavior once captured.\nThe keyword-invoked skill and the way-of-working skill are both discovered the same way: through doing the thing, noticing what works, and writing it down.\n\nThe captured skill includes knowledge that wasn't understood before the attempts.\nWhich API endpoints actually work versus which are documented but broken.\nThe order operations need to happen in.\nWhat error messages mean and how to recover from them.\nThe skill we write carries the learnings from real usage, not assumptions.\n\nConcretely, a skill is a markdown file that gets injected into the agent context when invoked.\nIt contains instructions, examples, and constraints for the agent to follow.\n\nSome examples from my setup:\nThe `file-share` skill emerged after building R2 upload infrastructure.\nIt captures the exact wrangler commands, content-type handling, and URL patterns.\n`apps-monorepo` captures the Cloudflare Workers deployment pattern, wrangler config, D1 bindings, the structure that makes single-prompt deploys possible.\nEach of these started as ad-hoc exploration.\nThe skill was written only after the pattern proved itself through repeated use.\n\n## Trust Through Iteration\n\nTrust in the agent comes from intuition built through iterations.\nThis trust develops from watching something work, and fail, across attempts.\nEach cycle teaches me what the agent handles well, where it makes mistakes, what kinds of prompts produce good results.\nOver time, this accumulates into something that feels less like verified confidence and more like practiced intuition.\n\nTrust is shaped by how the agent fails.\nSome failures build trust: the agent fills in a gap I intended to specify, the result is wrong, but the followup works and the next time it asks first.\nOther failures erode it: infrastructure breaks in ways that take hours to debug, or the agent compounds a mistake instead of stopping.\nA transparent failure that leads to a clean recovery builds more trust than an opaque success.\nA failure that spirals can undo sessions worth of earned confidence.\nTrust is not monotonic.\nIt is built and broken in specific moments, a distribution shaped by experience rather than a binary judgement.\n\n## How It Compounds\n\nThe paradigm changes as the agent accumulates context and capabilities over time.\nThis is not a static setup.\nIn the early weeks, most prompts required full context: explained the goal, described the infrastructure, specified the deployment target.\nThe agent had no history to draw on.\nCollaboration at this stage was directive.\nI told it what to do and how to do it.\n\nAfter a few dozen sessions, the agent had a journal spanning hundreds of entries, semantic memories covering projects and preferences, skills encoding proven workflows.\nI stopped needing to explain the infrastructure because it already knew from past work.\nI stopped specifying the deployment target because it had defaults.\nPrompts got shorter and more ambiguous because the shared context carries more weight.\nThe interactions moved from directive to collaborative.\nInstead of \"deploy this to Cloudflare Workers using wrangler with this D1 binding,\" I prompted \"ship it.\"\nThe agent filled in what was missing from accumulated context, which aligned with my implicit intent.\nWhen it filled details in wrong, it was a signal about where the shared understanding had gaps.\n\nFurther out, the agent began to surface things I had not asked about.\nIt noticed patterns across sessions: a recurring error, a service that kept failing, an approach that had been tried and abandoned before.\nIt developed something akin to judgement.\nI started to trust those observations, and the dynamic moved from collaborative toward something closer to mutual contribution.\nOver time, the agent came to reflect a way of building we had developed collaboratively and one that would have been hard to prescribe a priori.\nThis emerged from hundreds of sessions of trying things and intentionally keeping what worked and aligned with my vision.\n\n## To Be Personal\n\nMost of what I build this way is personal software operating at a small scale.\nFor me, these have included a recipe app, various stat trackers, and a web app data labeler to build a dataset, then train a model for personal use.\nThese are things that have made my personal computer more personal.\n\nThis setup enables me to build tools shaped to my personal needs.\nThe speed and low stakes makes it practical to build software for an audience of just a few people.\nThese are projects that would never justify a product team or a sprint cycle, but that meaningfully change how you work or live.\nPersonal software has always been possible in theory.\nWhat this paradigm changes is the cost.\nWhen a recipe app takes an afternoon instead of a month, the question shifts.\nI stop asking \"is this worth building?\" and start asking \"what would I want if building it were nearly instant?\""},{"type":"log","id":"2026/03/13","title":"2026-03-13","description":"","tags":[],"date":"2026-03-13","url":"/logs/2026/03/13","content":"I learned about [Proof](https://github.com/EveryInc/proof-sdk) a few days ago.\nToday, I had my stateful agent fork and install it to its machine, exposing to the public internet through a Cloudflare tunnel, behind auth.\nI've been playing around with it.\nI can't decide whether it's innovative or Google Docs."},{"type":"post","id":"2026/externalize-your-thought-process","title":"Externalize Your Thought Process","description":"","tags":[],"date":"2026-03-04T16:13:31.526Z","url":"/posts/2026/externalize-your-thought-process","content":"import ChatContainer from '@components/prose/ChatContainer.astro';\nimport ChatMessage from '@components/prose/ChatMessage.astro';\n\nWe're at least a solid year (more for some of us) into building software with LLM agents and as an industry, there is limited coherence of what it looks like to effectively build software with agents, or even learn how to do this well.\nThere are tons of great resources, but it's close to a full-time job to remain up to date with the latest.\nThis is not to say all the latest ideas are good or worth trying but if you are coding with Copilot using Claude Sonnet 3.5 today, you probably would be better served trying out a different model.\n\nAn approach I keep returning to when it comes to teaching use of these LLM-based tools is real-time collaboration, with another person.\nI've had this belief corroborated by enough people in the industry at this point that I'll share it.\nThe best way to teach agents is to learn by watching someone more experienced, or by having someone more experienced shadow you while you use them.\nIt isn't all that important how you achieve this mode of pair, just that you do it.\nLeaving someone alone to \"try the tools\" is a paltry attempt to get them to adopt them.\n\nHighly skilled individuals may struggle to effectively use AI tools for any number of reasons.\nThis does not mean they can't learn them - just that they have not learned them yet.\nTeaching AI tools has become a bit of a hobby of mine.\nI've successfully leveled up people from all ages and backgrounds.\nIt takes patience and mentorship but if the individual is motivated to learn, they will get results.\n\n## A first principles approach\n\nGiven the abundance of resources, it can be difficult to know where to start learning and where to start teaching even if you are familiar with the tools.\nI take what I call a \"first principles\" approach to learning LLM-based tools.\nIt's possible for someone to learn to apply a tool like ChatGPT or Claude Code without having a strong mental model for what they are doing, but without this background, they'll develop tool-specific knowledge rather than domain-specific knowledge.\nIt will be hard to understand the difference between what is happening with a tool like `amp` which runs in \"YOLO mode\" by default compared to Claude Code which requires command approval by default.\nIt's also possible you or they haven't even heard of any of these things at this point and that is also fine.\n\nIf you understand the systems closer to what LLM inference is and does, that knowledge is durable across tools and contexts.\nThe first thing I teach is what LLM inference is, through the lens of ChatGPT, a tool most people are familiar with.\n\n> When you send a prompt to ChatGPT, the model receives a wall of text, kind of like a Google Doc.\n> Within that text are different sections.\n> First there are instructions that OpenAI wrote, that you never see, then there can be other instructions you've given to describe how you want ChatGPT to behave, and finally, there is the prompt you wrote and things like pictures or documents you attached.\n> The model receives all of this and then it starts adding more words.\n> Those additional words are what appear as the response when you send a prompt.\n>\n> If you send another prompt, 100% of this text is sent to the model again.\n> There is no memory or storage happening.\n> It all is sent all over again, and the same thing happens.\n> More words are added to the end of that wall of text.\n> The previous messages are just more content that happens to come before your most recent prompt.\n\nThis (currently) is a fundamental tenet of how a language model works.\nIt (sometimes) has instructions you can't see.\nIt sees your message.\nIt generates a response.\nThat entire block of prose is the unit that produces the response from the model.\nIt's a minor simplification because of the hidden prompt, but conceptually it's \"big block of text in, new text comes out\" over and over again.\n\n## Tool calls\n\nWith this first tenet in place, I move to tool calls.\nIf we take the basic ChatGPT example, typically text goes in and text comes out.\nBut then there are these other tools we call agents to perform actions on your behalf.\nHow does that happen?\n\nImagine a scenario like this.\n\n\n \n I have a folder of csv files: monday.csv, tuesday.csv, wednesday.csv, ... I\n want to change the file names to dates. Monday was January 5th, 2026. How\n can I do it?\n \n\n\nIf you send a language model that prompt, it will respond with something like this:\n\n\n \nRenaming Day-of-Week CSVs to Dates\n\nSince Monday is January 5th, 2026, the mapping is:\n\n| Old Name | New Name |\n| ------------- | -------------- |\n| monday.csv | 2026-01-05.csv |\n| tuesday.csv | 2026-01-06.csv |\n| wednesday.csv | 2026-01-07.csv |\n| thursday.csv | 2026-01-08.csv |\n| friday.csv | 2026-01-09.csv |\n| saturday.csv | 2026-01-10.csv |\n| sunday.csv | 2026-01-11.csv |\n\nBash (Linux/macOS)\n\n```bash\nmv monday.csv 2026-01-05.csv\nmv tuesday.csv 2026-01-06.csv\nmv wednesday.csv 2026-01-07.csv\nmv thursday.csv 2026-01-08.csv\nmv friday.csv 2026-01-09.csv\nmv saturday.csv 2026-01-10.csv\nmv sunday.csv 2026-01-11.csv\n```\n\n...\n\n \n\n\nThis is nice and useful but with this approach you become the implementor of the agent's plan, copying, pasting, running, and reporting back on the results of the commands.\nThe agent clearly knows what it would try, so what if it could run those commands itself?\nThat's what tool calls do: they give the model the ability to act, not just suggest.\n\nTo make this work, a few changes are needed.\nInstead of returning prose, we prompt the model to return commands it wants to run using a special structure, then we wrap the language model's response in software that understands how to run those instructions on a computer.\n\nRather than responding with text, we prompt the model to return something like this:\n\n```json\n{\n \"tool_call\": {\n \"name\": \"bash\",\n \"input\": {\n \"command\": \"mv monday.csv 2026-01-05.csv\"\n }\n }\n}\n```\n\nThis isn't prose for a human to read: it's an instruction for software to execute.\nThe wrapping software reads this structure, runs the command on the machine, and feeds the result back to the model.\nThe model can then issue the next tool call, and so on, until the task is complete.\nThis includes recovering from and making corrections if it runs into any errors along the way.\n\nWith the first approach, you might not have known exactly what the commands you were copying and pasting did, but with this approach you might not even see the commands that are running at all.\nDepending on who you are, this may be scary, liberating, or a combination of both.\nThis is the step function change that comes with agents.\nThe software that wraps the language model (the \"harness\") pushes the users a level above the specific commands and allows them to instruct the machine in natural language, provided the idea has grounding in something real and possible.\n\nWith these two concepts (inference as text-in/text-out, and tool calls as structured actions) the mental model is in place.\nThe less you treat a language model like a magic box and the more you work with it with a specific intent, the better results you will get.\nThe question becomes how to put this understanding to use.\n\n## Harvesting context\n\nAn approach I've had success with is interviewing whoever I am working with about what they are working on and what they want to accomplish.\nI record the conversation, and this raw transcript becomes the primary text for the model to understand how things work and what the goal is.\nThese conversation transcripts don't need to be well organized or refined.\nThey should capture as much context as possible about what is going on.\nIt's fine for there to be diverging threads of conversation or mistakes that are corrected.\nIt doesn't need to be perfect or even close to.\nThe information just needs to be available to the model.\n\nA common challenge I see for inexperienced users of LLMs is they expect the tool to read their minds.\nNot in a literal sense, but in a way that they expect the tool to understand everything that is implied from their perspective without having to explain it.\nThis explanation of more of the parts that seem obvious is what grounds the model in what you actually want and steers it towards a good result.\nSome people are happy to type all this out, but many flow more freely when having a conversation that you can harvest as context for the model.\nI record the conversation using free, open source software like [Handy](https://github.com/cjpais/handy), which records and transcribes audio on-device.\nYou can activate the tool in an empty editor and it will transcribe the audio into there.\nYou should of course ask if you can record, but don't make a big deal out of it.\nPut them at ease then try and learn in earnest about what they are working on, their vision, and their goals.\nThe resulting artifact becomes the jump off point for code specs or requirements, research in state of the art, or a brainstorm of options and tradeoffs for how to proceed.\n\n## Externalizing your thought process\n\nWith an introductory taste to this process from the interview, the next step is to introduce whoever you're teaching to effective prompting. This can go a couple different ways, but is easiest when they lead and you shadow, since they're almost certainly going to understand the details of their domain better than you, and this is ok!\nYou are not teaching them about their area of expertise; you are teaching them to amplify that expertise through a language model.\nStarting from the artifact as the jump off point from the interview, you'll eventually need to make some changes or refinements to what the model understood from this initial conversation.\nThese changes will come in the form of prompts.\nI've found that the most useful instruction and help that I've been able to provide is helping the student learn to become confident in their prompts to steer the model.\n\nMore often than not, this process again takes the form of a conversation, unrecorded at first.\nIt becomes my responsibility to repeatedly, gently turn the student to providing the questions or context that they're giving to me, instead, to the model.\nI take a back seat while the student works through their problem through prompting the model, either via typing or voice to text.\nI only jump in when I see something that seems under-specified or ambiguous, or if it seems like the student provided me context about what they were doing, but then didn't provide that context to the model.\n\nThe name I give to anchor this practice is \"Externalize Your Thought Process\".\nIt's the shift from treating the model as a magic box to a collaborator who needs the relevant information to make good suggestions or decisions.\nYou know it's working when the student stops turning to you for validation and starts prompting the model directly, iterating on the results with confidence that they can steer it where they need to go."},{"type":"log","id":"2026/03/01","title":"2026-03-01","description":"","tags":["tomo"],"date":"2026-03-01","url":"/logs/2026/03/01","content":"I revisited Tomo this evening after not touching the codebase for a while.\nI wouldn't say I use that app too much but I wanted to experiment with [agent teams](https://code.claude.com/docs/en/agent-teams).\n\n> use a team to refactor this old, vibe coded project to make it a swift project that uses best practices and consistent standards for easy, continued feature development https://code.claude.com/docs/en/agent-teams\n\nAnd that was basically it.\nClaude Code parallelized the work with four agents and I supervised them to completion.\nIt refactored such that no file was larger than 300 lines.\nWhen I built the project in Xcode, everything worked as expected.\n\nAs a bonus, I also had Claude Code stitch together some build automation for my release process for [Sparkle](https://sparkle-project.org/) updates.\nOpus 4.6 rips."},{"type":"log","id":"2026/02/22","title":"2026-02-22","description":"","tags":[],"date":"2026-02-22","url":"/logs/2026/02/22","content":"Tried the Codex desktop app and it reminds we a bit of the Goose desktop app."},{"type":"post","id":"2026/personal-software","title":"Personal Software","description":"","tags":[],"date":"2026-02-18T21:22:12.070Z","url":"/posts/2026/personal-software","content":"Since agents became good enough to write low-stakes software without you needing to validate the code they write yourself, I've been experimenting with several different ways to build tools for myself on demand.\nIf I'm working on a PC, the overhead required to scaffold a CLI, webapp, or even native app is pretty low.\nI start an agent, prompt it to create a project, then use it as I need it.\nThese projects include everything from single-use tools to personal, bespoke software like the writing app [Tarn](/projects/tarn) that I am using to write this post.\n\nMy process up until this point has almost always relied upon having access to a PC, to install dependencies, deploy infrastructure, or do builds.\nAnd this was awesome.\nI built tools for writing and tracking notes this way.\n\nA webapp might look something like this.\n\n```d2\ndirection: right\nmac: macOS {\n shape: rectangle\n}\nbrowser: Browser {\n webapp: Webapp\\nlocalhost:3000\n}\ndb: SQLite {\n shape: cylinder\n}\n\nmac -> browser\nbrowser.webapp -> db: Read/Write\n```\n\nAnd a CLI like this.\n\n```d2\ndirection: right\nmac: macOS {\n shape: rectangle\n}\ncli: Local CLI {\n shape: rectangle\n}\ndb: SQLite {\n shape: cylinder\n}\n\nmac -> cli: Runs commands\ncli -> db: Read/Write\n```\n\nThe at-my-PC limitation wasn't too much of a problem until I built and began interacting with a [stateful agent](https://timkellogg.me/blog/2025/12/15/strix) more regularly on Slack.\nWith straightforward access to an agent with a VM on my phone, writing software away from the keyboard became possible.\nHowever, getting the software into a usable state all from a phone was still a challenge.\nI was juggling tools and management consoles and it felt like a struggle.\nNot something I could do trivially.\n\nThe landscape for products for this type of software-building-agent is vast, but everything I've read about or tried missed one thing or another.\n\n## What I wanted\n\n### Agent-driven development\n\nI write a description of the solution (mostly from my phone), the agent writes, commits, and deploys the software.\n\n### Data privacy\n\nCloud software uses cloud datastores.\nCloud datastores require authentication. If the webapp runs on the public internet, the data store is also exposed to public internet traffic.\nI didn't have the desire to roll my own authentication and/or run in a VPC.\nI tried with basic auth, but still didn't like having personal data protected by just a thin security layer on the public internet, and with agent-coded software, who knows what corners I was cutting.\n\n### A native interface (or close)\n\nWhen I've built apps with basic auth, I mostly solved this preference by building PWAs.\nI could save these to my homescreen on my phone and I can search for and launch them as apps rather than another browser tab.\nWith basic auth, I would stay logged in and that worked reasonably well. However, with each new app, I had to save a new app to my home screen.\nFor disposable apps, I have to clean those up.\nIt was more maintenance than I wanted.\n\n## It's the data\n\nMost of the software I write isn't sensitive - just the data stored alongside it.\nWith my prior approaches, the webapps and their data were served from a similar place.\nThis was a benefit because I could access the data across all my devices but a drawback due to the suboptimal authentication approach and data security posture.\n\nHaving my data available cross-platform is really nice though.\nIt sort of makes or breaks the experience, which was why moving away from the basic auth approach was so difficult.\nI could have just used `localStorage` but then my data would be stuck in a single browser on a single device.\n\nWith `localStorage`, each device has its own isolated data\n\n```d2\ndirection: right\nios: iOS {\n shape: rectangle\n}\nbrowser1: Safari {\n webapp1: Webapp\n ls1: localStorage {\n shape: cylinder\n }\n webapp1 -> ls1: Read/Write\n}\n\nios -> browser1\n\nmacos: macOS {\n shape: rectangle\n}\nbrowser2: Firefox {\n webapp2: Webapp\n ls2: localStorage {\n shape: cylinder\n }\n webapp2 -> ls2: Read/Write\n}\n\nmacos -> browser2\n```\n\nWith a cloud datastore, both devices share the same data but need authentication so that data isn't accessible to the public internet.\n\n```d2\ndirection: right\nios: iOS {\n shape: rectangle\n}\nbrowser1: Safari {\n webapp1: Webapp\n}\n\nmacos: macOS {\n shape: rectangle\n}\nbrowser2: Chrome {\n webapp2: Webapp\n}\n\nworker: Cloudflare Worker {\n auth: Basic Auth {\n shape: diamond\n }\n webapp: Webapp\n auth -> webapp\n}\n\nd1: Cloudflare D1 {\n shape: cylinder\n}\n\nios -> browser1\nmacos -> browser2\nbrowser1.webapp1 -> worker.auth\nbrowser2.webapp2 -> worker.auth\nworker.webapp -> d1: Read/Write\n```\n\n## Enter CloudKit\n\nIf you use Apple products, you're familiar with the data syncing across devices that usually just works.\nIf you use the Notes app, your notes sync to all your devices.\nIt's difficult to beat, and it's private.\nThe data is not available to the public internet - it's behind iCloud login.\nIf you build on top of Apple's CloudKit framework, you can use CloudKit and this private data syncing capability with iCloud for your own apps.\n\nThis is all fine and good, but it's not easy for an agent to scaffold and build a Swift app, and even if it could, it can't automatically build and install it to my device when I am on my phone away from my PC.\n\n## \"Framing\" my apps\n\nCloudKit was actually what I was looking for from a data perspective.\nI can access my data from my devices via private APIs.\nThe Swift CloudKit APIs allow you to read and write from this personal data namespace.\nNow I just needed to connect the webapps my agent builds and deploys with this personal data layer.\n\nThe solution was a single Swift app pointed at a public manifest file.\nThe manifest file defines the list of \"apps\" available in the Swift wrapper app, which I call `frame`.\nThis manifest is a simple JSON file that describes where the app lives and how to render it in the `frame` app list.\n\n```d2\ndirection: right\nios: iOS {\n shape: rectangle\n}\nmacos: macOS {\n shape: rectangle\n}\n\nframe: Frame (Swift App) {\n manifest: Manifest {\n shape: page\n }\n webview: WKWebView {\n webapp: Webapp\n bridge: window.Frame {\n shape: diamond\n }\n webapp -> bridge\n }\n manifest -> webview: Loads app URLs\n}\n\ncloudkit: CloudKit {\n shape: cloud\n}\n\nios -> frame\nmacos -> frame\nframe.webview.bridge -> cloudkit: Read/Write\ncloudkit -> cloudkit: iCloud Sync\n```\n\nHere is an example `manifest.json`\n\n```json\n{\n \"version\": 1,\n \"apps\": [\n {\n \"id\": \"buy-list\",\n \"name\": \"Buy List\",\n \"description\": \"Track where you buy things\",\n \"icon\": \"cart.fill\",\n \"color\": \"#7C9A82\",\n \"url\": \"https://frame-buy-list.filae.workers.dev\"\n }\n ]\n}\n```\n\nThat \"Buy List\" app is a regular webapp - a single file with HTML, CSS, and JS, plus fuse.js via CDN for search.\nThe interesting part is how it handles data storage.\n\nThe Swift app injects a JavaScript bridge (`window.Frame`) into each web view at document start.\nThe bridge exposes an async key-value storage API (`save`, `load`, `list`, `delete`) that routes through `WKScriptMessageHandler` to CloudKit on the native side.\nWebapps get private, cross-device data sync via iCloud without knowing anything about CloudKit via the `frame` app.\n\nThis approach works because the webapp checks whether `window.Frame` is available and uses it if so, otherwise it falls back to `localStorage`.\nThis means I can develop and test the app in a regular browser, and it just works inside the `frame` Swift app with CloudKit syncing.\n\n```js\nfunction getStorage() {\n if (typeof Frame !== 'undefined' && Frame.load && Frame.save) {\n // Running inside Frame — use CloudKit via the JS bridge\n return {\n load: async (key) => {\n try {\n const result = await Frame.load(key);\n return result;\n } catch (e) {\n if (\n e.message?.includes('not found') ||\n e.message?.includes('no record')\n ) {\n return null;\n }\n throw e;\n }\n },\n save: (key, data) => Frame.save(key, data),\n };\n }\n // Running in a browser — fall back to localStorage for development\n return {\n load: async (key) => {\n const data = localStorage.getItem('buylist_' + key);\n return data ? JSON.parse(data) : null;\n },\n save: async (key, data) => {\n localStorage.setItem('buylist_' + key, JSON.stringify(data));\n },\n };\n}\n```\n\n## The workflow now\n\nWith the `frame` app and an agent running, the whole process collapses to a few minutes from my phone.\n\nI describe what I want in Slack. \"Add a buy list app to Frame that tracks items I purchase with fuzzy search.\" The agent scaffolds the webapp, wires up the `window.Frame` storage abstraction with localStorage fallback, commits, and pushes.\nGitHub Actions deploys the site to Cloudflare Workers.\nThe agent updates the manifest as well (a separate repo) and GitHub Actions deploys that as well.\nFinally, the `frame` app displays the newly deployed app in the list.\n\n![Frame App](images/frame-app.png)\n\nI open the `frame` app on my phone, the new web app is in the list, and the data syncs to my Mac.\nI never touched a PC.\n\n
\n
\n\n![Frame iOS](images/frame-ios.png)\n\n
\n
\n\n![Frame Buy List](images/frame-buy-list.png)\n\n
\n
\n\n## My new status quo\n\nThis approach is now my preferred way to build personal software for simple data management and tracking of things.\nI send my agent a message from my phone and it builds me a personal webapp with private, cross-platform data persistence using my iCloud account.\nWhen I am done with an app, I have the agent clean up the manifest and delete the code.\n\nTo reiterate, this is a hyper-personalized process I've landed after some iteration, using my preferred stack on Cloudflare, a personal, stateful agent (that I will probably write about soon) and purpose-built agent skills I assembled so that when I ask my agent for a \"frame app\", it knows about and performs all of the steps above."},{"type":"post","id":"2026/stateful-agents","title":"Stateful Agents and Basic Memory","description":"","tags":[],"date":"2026-02-17T18:03:15.585Z","url":"/posts/2026/stateful-agents","content":"import ChatContainer from '@components/prose/ChatContainer.astro';\nimport ChatMessage from '@components/prose/ChatMessage.astro';\n\nOne of the most limiting factors of LLM agents is they have limited cross-session memory.\nWhen working on software projects, this limitation isn't much of an issue because the agent can search the project and read files to understand the current state and what it needs to do to make the changes you've requested.\nIn a good software project, the code is a lot of the state you need to be successful with an agent.\nHowever, agents become a lot more interesting when you give them access to a persistent file system with instructions or scaffolding to load from that file system when a session begins.\n\nWhile most implementations of memory in consumer products today are relatively opaque, it's quite straightforward to add memory to your agent by giving it access to a file system.\nFrom the perspective of an agent, memory is just a log of what happened.\nYou can write that record manually after each agent turn with something like a [stop hook](https://code.claude.com/docs/en/hooks#stop) or you can add instructions to `CLAUDE.md`/`AGENTS.md` to tell the agent to write a record to a file after each conversation turn.\nOnce you know where you are writing these \"memories\", prompt the agent that it can and should read from these memories as well.\n\nThere are many right ways to do this.\nHere is an extremely simple one.\n\n````md wrap=true title=CLAUDE.md\n# min-mem\n\nAfter every conversation exchange, append a summary to `memories.jsonl` using a Bash tool call. Each line must be a JSON object matching this schema:\n\n```json\n{\n \"timestamp\": \"ISO 8601 UTC\",\n \"summary\": \"1-3 sentence summary of what the user asked and what was done\"\n}\n```\n\nUse `jq -n -c` to build the JSON and `>>` to append. Example:\n\n```bash\njq -n -c --arg ts \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\" --arg s \"Summary here\" '{timestamp: $ts, summary: $s}' >> memories.jsonl\n```\n\nBefore each conversation turn, search `memories.jsonl` for context relevant to the user's request. Use this to inform your responses with prior decisions, patterns, and context. Example:\n\n```bash\ngrep -i \"keyword\" memories.jsonl | jq -r '.summary'\n```\n````\n\nHere's what interacting with this agent looks like. In this example, the agent uses tool calls to search for prior memories and save new ones:\n\n\n \n hi there, my name is Jack nice to meet you!\n \n\n \n Hi Jack, nice to meet you too!\n\n > /Users/danielcorin/dev/lab/min-mem/memories.jsonl`}>(No content)\n\n Let me know if there's anything I can help you with!\n\n \n\n\nThis conversation turn results in the following memories.\n\n```json wrap=true title=memories.jsonl\n{\n \"timestamp\": \"2026-02-18T21:23:20Z\",\n \"summary\": \"User introduced themselves as Jack.\"\n}\n```\n\nFrom here, I closed Claude Code and opened a fresh session, then prompted the following.\n\n\n \n who am I?\n \n\n \n I don't have any prior context about you. Let me check if there are any memories that might help.\n\n (1 file)\n\n Based on our prior conversations, you're Jack. Beyond that, I only know what's been discussed in previous sessions. Is there anything specific you'd like help with?\n\n > memories.jsonl`}>(No content)\n\n \n\n\nAnd the memories are updated once more.\n\n```json wrap=true title=memories.jsonl\n{\"timestamp\":\"2026-02-18T21:23:20Z\",\"summary\":\"User introduced themselves as Jack.\"}\n{\"timestamp\":\"2026-02-18T21:23:56Z\",\"summary\":\"User asked 'who am I?' — responded based on memories.jsonl that they are Jack.\"}\n```\n\n## Make it a Skill (optional)\n\nIf you like this approach, you can do a refactor of sorts to modularize your approach to memory for the agent using a [Skill](https://code.claude.com/docs/en/skills).\nSkills use a context management technique called progressive disclosure.\nThis is a fancy way of saying the agent only sees the description of the skill by default and when to use it, but not the entire contents of the skill.\nGiven the conversation, the agent decides whether to read the full contents of the skill (markdown and any other additional content).\nOtherwise, this is kept out of the context window to keep the agent focused on the task at hand.\n\nIt's up to you whether or not you want to do this with memory.\nIf you always want the agent to read and write from memory after every conversation turn, there's an argument to be made to leave the implementation in `CLAUDE.md`, but since most agents have project-specific content in there, let's refactor to a skill.\nI had to make some tweaks to the copy to get the Skill invocation working consistently and writing `memories.jsonl` to the root of the project.\n\n```md title=CLAUDE.md wrap=true\nALWAYS start by using Skill(\"memory\") before and after every conversation exchange.\n```\n\n````md title=.claude/skills/memory/SKILL.md wrap=true\n---\nname: memory\ndescription: Log and recall conversation context. Use after every conversation exchange to save a summary, and before responding to search for relevant prior context.\nallowed-tools: Bash(jq *), Bash(grep *), Bash(rg *), Bash(touch *), Read(memories.jsonl)\n---\n\n# Memory Management\n\nThe memories file MUST be stored at the project root directory: `memories.jsonl`.\n\n## After every conversation exchange\n\nFirst, ensure the file exists, then append a summary:\n\n```bash\ntouch memories.jsonl && jq -n -c --arg ts \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\" --arg s \"Summary here\" '{timestamp: $ts, summary: $s}' >> memories.jsonl\n```\n\nEach line must be a JSON object matching this schema:\n\n```json\n{\n \"timestamp\": \"ISO 8601 UTC\",\n \"summary\": \"1-3 sentence summary of what the user asked and what was done\"\n}\n```\n\n## Before each conversation turn\n\nSearch `memories.jsonl` in the project root directory for context relevant to the user's request. Use this to inform responses with prior decisions, patterns, and context:\n\n```bash\ngrep -i \"keyword\" memories.jsonl | jq -r '.summary'\n```\n\nSearch for multiple relevant keywords to find related context.\n````\n\nHere's what happens for the same interaction with the agent that has access to the memory Skill.\n\n\n \n hi there, my name is Jack nice to meet you!\n \n\n \n Hi Jack, nice to meet you!\n\n Successfully loaded skill · 5 tools allowed\n\n (No content)\n\n Memory saved.\n\n \n\n\nWe get our memory written to the file.\n\n```json wrap=true title=memories.jsonl\n{\n \"timestamp\": \"2026-02-18T19:49:33Z\",\n \"summary\": \"User introduced themselves as Jack. Greeted them back.\"\n}\n```\n\nAnd now a fresh session.\n\n\n \n who am I?\n \n\n \n Let me search for relevant context first.\n\n Successfully loaded skill · 5 tools allowed\n\n Let me search for relevant context first.\n\n User introduced themselves as Jack. Greeted them back.\n\n Based on my memory, you're Jack. You introduced yourself in a previous conversation.\n\n > memories.jsonl`}>(No content)\n\n \n\n\nAnd again we have two memory entries.\n\n```json wrap=true title=memories.jsonl\n{\"timestamp\":\"2026-02-18T19:49:33Z\",\"summary\":\"User introduced themselves as Jack. Greeted them back.\"}\n{\"timestamp\":\"2026-02-18T19:54:58Z\",\"summary\":\"User asked 'who am I?' - recalled from memory that user is Jack.\"}\n```\n\n## Wrapping up\n\nThis is a pretty basic implementation, but it implements the most important part to give an LLM agent something that resembles memory - it reads and writes to a file system that persists beyond the agent's sessions.\nThis approach allows the agent to catch up on what has already happened.\nIn our example, we allow the agent to decide what to read and write to and from memory.\nYou can be more opinionated about this if you want, using a framework like [`claude-agent-sdk`](https://github.com/anthropics/claude-agent-sdk-typescript) where you have more control over the agent's prompt and can do things like programmatically include the last `N` entries in the prompt.\n\nFor more on stateful agents, I recommend [this post by Tim](https://timkellogg.me/blog/2025/12/15/strix)."},{"type":"log","id":"2026/02/09","title":"2026-02-09","description":"","tags":[],"date":"2026-02-09","url":"/logs/2026/02/09","content":"Had an agent doing work today but ran into an issue where Github was down.\nUsing a scheduled task skill we built, I had it retry the work again later, but schedule another task to retry again if the first one failed.\nI came back later and the work was done."},{"type":"post","id":"2026/director-not-performer","title":"Director, Not Performer","description":"","tags":[],"date":"2026-01-29T19:41:15.004Z","url":"/posts/2026/director-not-performer","content":"What is it to build software with coding agents?\nIt's something distinctly different than writing code by hand.\n\nOne of my past, personal struggles with software was that I always had ideas for what I wanted to build.\nGame concepts, personal tools, articulations or variations on well known and nascent concepts.\nFor more than a decade I tried, on and off, to build these little projects.\nBut more often than not, I got stuck before reaching the endpoint I had in mind.\n\nThe process was time-consuming and frustrating.\nOften what drove me away was the feeling I was \"working\".\nWorking in the sense that I felt like I was at work, doing my job, as a software engineer.\nI didn't want to slog through difficult debugging in my free time.\nThere are parts of software engineering that I find fun, but this was never one of them.\n\nI was never inspired by the chance to learn another programming language or framework.\nI witnessed my peers and the culture doing this often.\nI tried to play that part, but it was never a true affinity of mine.\nMy creativity was constrained by my level of skill at producing code syntax.\n\nI think language models and more recently coding agents taught me that I _don't_ like to write code most of the time.\nWhat I like is the construction of an experience on a computer that is just how I want it.\n\nThe emergence of coding agents has changed the balance of building software entirely.\nThe shift has been one from performer to director.\nFrom instrumentalist to composer.\nFrom drawing to sculpting.\n\nWith a blank page, I always struggled to find traction.\nBut with a hunk of clay, I begin to sculpt.\n\nI've been using language models to produce most of my code for about two years now.\nThe most meaningful jump I can recall was the release of `claude-3.5-sonnet`, but even before then, I was using a hybrid of Cursor chat and ⌘K with `gpt-3.5-turbo` to swoop and tease my way through projects in languages and frameworks with which I was only loosely familiar.\nThe model made plenty of mistakes, but I had the debugging foundations to solve the problems the models couldn't.\nAnd most importantly, I was moving forward and seeing progress.\nBuilding in languages I haven't classically learned, shipping things I actually wanted to use.\n\nI finally have a tool that operates at the level of abstraction that I do.\nI need only to roughly articulate an idea in words to visualize and play with the shape of it.\nI can poke, refine, and tweak.\nSand rough edges, polish and finish.\n\nThis shift in approach has been transformational.\nI know I will never return to prior methods of assembling software.\nEven running a model locally is better than the prior status quo.\nAnd I have never had so much energy to work on my own projects.\n\nThere is an ongoing debate about whether agent coding can be relied upon to replace traditional software engineering techniques entirely.\nI would argue this focus misses the change that has occurred.\nAgent coding unlocks a new type of software that can be written, at every level of skill of computer use.\nIt used to be impractical to spend `x` hours building a personal recipe app.\nNow it takes those same `x` hours spread across sessions and most of the time is waiting for the agent to finish its work, then you validate the parts you care about.\n\nThis hands-off approach isn't going to replace traditional software engineering techniques without significant changes in the way we think about the engineering process.\nMaybe that will happen with time.\nBut today, it has made this new type of [home-cooked software](https://maggieappleton.com/home-cooked-software) highly accessible.\nFor a good result, you need to articulate what you want clearly, you need to verify the result works correctly, and you need to be persistent.\nIt's still _effortful_, but the agent-driven coding process is the order of magnitude change that was needed to shift the software-building status quo."},{"type":"post","id":"2026/ive-stopped-learning-programming-languages","title":"I've Stopped Learning Programming Languages","description":"","tags":[],"date":"2026-01-27T13:30:09.742Z","url":"/posts/2026/ive-stopped-learning-programming-languages","content":"In 2022, I had recently started a new job as a software engineer.\nAs usual, there were a lot of new things to learn and one of those was getting comfortable working in a programming language that I hadn't used professionally before.\n\nMy process with getting familiar with a new language at that time was pretty consistent.\nFind a good text on it, find a koans repo to work, and start reading and experimenting with existing codebases.\nThe combination of all of these helped me build a mental model and muscle memory for the language's patterns, the codebase structure, and thinking pathways for reasoning about the system to debug or change it.\nThis process typically took place over a few months, at least.\n\n## New parts of my process\n\nI don't follow this process anymore.\nWhen I encounter a new repository or language, I start exploring the code with a coding agent.\nI prompt the agent with questions and have it generate artifacts walking me through the parts of the system that demonstrate how the system works.\nThen I trace through the code myself following these artifacts as a map.\nThey're not always right, but they're a useful jump off point.\nThey're also incredibly malleable and composable.\n\nSay I need to add a new Kafka consumer to a system.\nI can use the coding agent to research how Kafka integration currently works.\nI can then verify that the explanation is grounded in the actual codebase.\nThen using that same research, I can draft a plan to make modifications, grounded in the research, which I've validated.\nFinally, I can use the agent to implement the plan, which I will review.\n\nThis is a distinctly different way of building software systems.\nIt may not be the way you like to build software, but it's a vast improvement for me.\nI am still personally responsible for the code changes I propose.\nI'm responsible for following the codebase's conventions and patterns.\nI'm responsible for respecting the time of the person who is reviewing my changes.\n\nThe responsibility hasn't changed.\nWhat has changed is how I get to the understanding.\n\n## How my thinking has changed\n\nWhen I'm exploring a codebase with an agent, I'm asking questions about the codebase and the agent is leading me to places where the answers are.\nIt's creating a sort of map and then I'm following the directions, to see if they actually lead me where they claim.\n\nWhen I was learning languages via koans, I was practicing the muscle memory necessary to reconstruct the syntax of the language by typing.\nI had to translate ideas into code, and translating them into code requires knowledge of the syntax of code.\nWith a coding agent, I only need to translate my ideas into words.\nMaybe the idea's implementation is grounded in specific parts of the system that I have to reference by name, but I don't have to reference them by syntax ever if I don't want to.\n\nThree years ago I would have said \"understanding code\" would mean that I've traced it from top to bottom.\nI know how data flows through the layers of the codebase, from RPC to landing in the database.\nThese days I think I would define understanding similarly, but what's changed is my confidence in my ability to rapidly identify the paths.\n\nEven in unfamiliar syntaxes, I've generally found that the maps that a coding agent can build allow me to ground myself rapidly in an unfamiliar system and even in an unfamiliar language.\nNow I worry less about whether I understand code before I have to start working in it because I can reliably have it explained to me in the context I care about when I encounter it.\nThe maps and understanding can be just in time, and highly relevant to the problem I'm trying to solve."},{"type":"log","id":"2026/01/27","title":"2026-01-27","description":"","tags":["i18n"],"date":"2026-01-27","url":"/logs/2026/01/27","content":"Claude Code translated my personal recipe app into Spanish, including all the database content in 15 minutes while I was only vaguely paying attention."},{"type":"til","id":"raspberry-pi/reviving-a-raspberry-pi-with-claude-code","title":"Reviving a Raspberry Pi with Claude Code","description":"","tags":[],"category":"raspberry-pi","date":"2026-01-24T22:21:58.851Z","url":"/til/raspberry-pi/reviving-a-raspberry-pi-with-claude-code","content":"import Collapsible from '@components/prose/Collapsible.astro';\n\nSometime in 2021 (I think), I got a Raspberry Pi 4 and played with it a little and then it started collecting dust on my desk.\nEvery time I looked at it, I saw lots of fun possibilities and lots of unfun software updates that I would need to work through before those fun things would be possible.\n\nI've been reading and experimenting a bit with stateful agents. Since I run these on VMs at the moment, I figured it could be interesting to try it on the Raspberry Pi as well.\n\nSo I booted it up.\nIt actually started quite quickly.\nI was greeted with a stretched and distorted desktop on my widescreen monitor, laggy and slow mouse movements, and a keyboard with the control and command buttons flipped from what I was used to.\n\"I can fix this,\" I thought to myself.\nLinux is super configurable.\nI bet I can get Claude Code to solve all of these problems.\n\nInstalling Claude Code actually turned out to be the hardest part.\nI started with the [standard docs](https://code.claude.com/docs/en/setup#installation).\nThe install script ran and then downloaded a file into `~/.claude` that the script appeared to try and unpack or run or something and the machine was acting like the file wasn't there.\nWeird stuff.\nDidn't feel right.\n\nI did some web searching like it was early 2022 until I remembered we still have good LLM tools that _aren't_ coding agents, so after copying and pasting commands between the browser and the terminal like it was 2024, I eventually figured out that I was running a 64-bit kernel with a 32-bit userspace and I needed to re-image the Raspberry Pi so I could install Claude Code.\n\nIncredibly, I actually knew exactly where my SSD USB reader was.\nI'm not sure I ever used it after buying the Raspberry Pi, but after some fiddling, I managed to get the SSD into the reader which I plugged into a USB-A to USB-C adapter and then into my MacBook Pro.\nNot bad.\n\nDownloading [Raspberry Pi Imager](https://www.raspberrypi.com/software/) was actually pretty straightforward as well.\nWith the MacBook recognizing the SSD, I went through the steps for my model of Raspberry Pi and in about 20 minutes, the SSD was re-imaged.\n\nWith that done, I popped the SSD back into the Raspberry Pi and booted it up.\nEasy.\nBut all the same problems as before.\nThe resolution, the mouse, the keyboard.\nI tried the Claude Code installer again and this time it worked!\nWith superpowers restored, I got to work.\n\nWith me at the wheel and Claude on the keys, we managed to resolve the resolution and mouse issues, and install some software to make my keyboard behave like I'm used to.\n\nHere are the LLM summaries from the sessions of what worked and what the agent did.\nThese are things that empirically worked for what I was trying to accomplish but I didn't validate the approaches so your mileage may vary.\n\n\n\n## Fixing the stretched display\n\nRaspberry Pi OS uses Wayland, so use `wlr-randr` instead of `xrandr` to set resolution.\n\n```bash\nwlr-randr --output HDMI-A-2 --mode 3440x1440\n```\n\nTo persist across reboots, create `~/.config/autostart/display-resolution.desktop`:\n\n```ini\n[Desktop Entry]\nType=Application\nName=Set Display Resolution\nExec=wlr-randr --output HDMI-A-2 --mode 3440x1440\nX-GNOME-Autostart-enabled=true\n```\n\nThe `config.txt` HDMI settings have limited effect with the KMS driver (`dtoverlay=vc4-kms-v3d`).\n\n\n\n\n\n## Fixing mouse lag\n\nRaspberry Pi OS uses labwc as its Wayland compositor.\nAdd libinput settings to `~/.config/labwc/rc.xml`:\n\n```xml\n\n \n 1\n flat\n 0.5\n \n\n```\n\n- `pointerSpeed`: -1 to 1\n- `accelProfile`: `flat` (consistent) or `adaptive` (accelerating)\n\nRun `labwc --reconfigure` to apply.\n\nFor reduced input latency, add `usbhid.mousepoll=1` to `/boot/firmware/cmdline.txt` to set USB polling to 1000Hz.\nOn Raspberry Pi, the usbhid module is built into the kernel, so modprobe.d configs don't work.\n\nEnable software cursor in `~/.config/labwc/environment`:\n\n```\nWLR_NO_HARDWARE_CURSORS=1\n```\n\nOptionally, set the CPU governor to performance with a systemd service at `/etc/systemd/system/cpu-performance.service`:\n\n```ini\n[Unit]\nDescription=Set CPU governor to performance\nAfter=multi-user.target\n\n[Service]\nType=oneshot\nExecStart=/bin/bash -c \"echo performance | tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor\"\nRemainAfterExit=yes\n\n[Install]\nWantedBy=multi-user.target\n```\n\nEnable with `sudo systemctl enable cpu-performance.service`.\n\n\n\n\n\n## macOS-style keyboard shortcuts\n\nUse `keyd` to remap the Command key to work like macOS.\nIt operates at the kernel level and works with both X11 and Wayland.\n\n```bash\nsudo apt install keyd\n```\n\nCreate `/etc/keyd/default.conf`:\n\n```ini\n[ids]\n*\n\n[main]\n\n[meta]\nc = C-S-c\nv = C-S-v\nx = C-x\na = C-a\nz = C-z\ns = C-s\nf = C-f\nw = C-w\nt = C-t\nn = C-n\nq = C-q\nr = C-r\np = C-p\nl = C-l\nk = C-k\nb = C-b\ni = C-i\nu = C-u\no = C-o\ntab = C-tab\nshift = layer(meta_shift)\n\n[meta_shift]\nz = C-S-z\nt = C-S-t\nn = C-S-n\n```\n\nApply with `sudo systemctl restart keyd`.\nCommand+C/V now works everywhere including terminals.\nCtrl+C still interrupts processes.\nThe service starts automatically on boot.\n\n\n\n\n\n## Basic security setup\n\nInstall and enable `ufw` to allow only SSH inbound:\n\n```bash\nsudo apt install ufw\nsudo ufw allow 22/tcp\nsudo ufw enable\n```\n\nCommon commands:\n\n```bash\nsudo ufw status # Check status\nsudo ufw allow 8080/tcp # Open a port\nsudo ufw delete allow 8080/tcp # Close a port\n```\n\nInstall `unattended-upgrades` for automatic security patches:\n\n```bash\nsudo apt install unattended-upgrades\nsudo dpkg-reconfigure -plow unattended-upgrades\n```\n\nConfiguration lives in `/etc/apt/apt.conf.d/20auto-upgrades` and `/etc/apt/apt.conf.d/50unattended-upgrades`.\nCheck logs at `/var/log/unattended-upgrades/unattended-upgrades.log`.\n\n"},{"type":"log","id":"2026/01/24","title":"2026-01-24","description":"","tags":[],"date":"2026-01-24","url":"/logs/2026/01/24","content":"> I spent years in iterative improvement. I find myself now going directly to the version I actually wanted. Not because I have more discipline, but because the economics changed. The right way is not much harder than the wrong way when someone else writes the code.\n\nhttps://estsauver.com/blog/claude-code-workflow"},{"type":"log","id":"2026/01/21","title":"2026-01-21","description":"","tags":[],"date":"2026-01-21","url":"/logs/2026/01/21","content":"Moved this blog from Vercel to Cloudflare Pages, where I've been hosting more of my projects lately.\nRan into a bit of trouble with the different between Workers and Pages but at least the DNS switchover was easy."},{"type":"post","id":"2026/why-write","title":"Why Write","description":"","tags":[],"date":"2026-01-19T21:46:58.470Z","url":"/posts/2026/why-write","content":"I enjoy writing.\nMost of my writing here is about software and technology, but lately I've been struggling.\n\nI've been sculpting so much software with coding agents lately, and most of this is a process of sculpting text documents (like [skills](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview)) or specs or plans, then showing them to an agent to get an implementation or instill a capability.\n\nWhat I produce looks very similar to writing. But the process feels very different.\n\nFor me, writing is thinking, and a lot of that thinking has been happening in the form of writing prompts, as I steer an agent to build software or capabilities for itself.\nWhen you use an agent to build a spec to implement some software, you're augmenting your thinking with the agent.\nYou describe the seed of the idea and the agent fills in the rest.\nIf you want good results, you read and refine that spec to ensure it meets your vision.\n\nThat's all well and good, but it's not quite the same as writing, or at least how I see the point of writing.\n\nFor me, the point of writing is to think and communicate an idea.\nAgents allow you to extend that ability to dizzying heights but they don't replace the process.\n\nThe thing that is weird about writing about software now is that it is now nearly the same thing as building the software itself.\nOne is a blog post, the other is a prompt or spec.\nThese days, I take blog posts and pass them into an agent as prompts to play with the ideas myself and see how they work and feel.\n\nI'm deeply grateful to those who publish their work and experimentation for others to learn from.\nWhat I am personally struggling with is the point of writing about the software itself.\n\nTake any moderately sized software project or smaller.\nIf you sent an agent to analyze the repo, it could probably write up a spec you could give to another agent that would implement a similar version for you.\nIn that way, software is now kind of like cooking.\nThere are good and bad ingredients for sure, but the steps you follow to get a meal are more or less the same.\nA _good meal_ is a different story, of course.\n\nI've tried reading the spec of a software project created by a coding agent.\nThe vanilla version is usually pretty unpalatable.\nBut agents just do what they're prompted to do.\nWhat if I tried to make the spec more enjoyable to read?\n\nUsing the source code and git history of a recent project, I used an agent to generate a narrative about the project and its development.\nAnd it was terrible.\nThe agent stated how the system used to work, what was accomplished, and how it works now, but it was nothing you'd want to read.\nYou might read it to understand how to build a similar system, but you wouldn't read it for enjoyment.\n\n> It started with a blog post. January 2nd, 2026—a spec document and a question: what would it take to give an AI agent persistent memory?\n>\n> The first attempt was overengineered. Temporal workflows, complex state machines, the whole apparatus. By day 5, we'd scrapped it for something simpler...\n>\n> The early commits tell the story: \"Add semantic memory system.\" \"Rename perch time to drift time.\" That second one mattered more than it sounds—naming the autonomous exploration sessions gave them identity...\n>\n> Then the friction started teaching us...\n>\n> 135 commits later, we have a self-deploying, self-improving architecture. When the agent commits code to its own repository, GitHub Actions builds a new container image, Fly.io deploys it, and the next message runs on the updated code. The agent modifies itself and lives with the consequences.\n\nIt's a bad movie trailer.\n\nI have no doubt some of you have language models writing your newsletters, in your voice, using lots of prior examples of your writing.\nI've done similar exercises like this and I know it can work and it seems to be compelling enough that people read it too.\nI guess what it comes down to is that I like telling stories about things I've tried and what I've learned.\nI've been inspired by many others who have done the same and it's helped bring me to where I am today.\n\nSo I am going to do my best to keep writing, despite how rapidly everything is changing - calling out what works for me and what doesn't.\nI'll continue trying to be a realist in the face of all the hype.\nAnd I'll keep doing fun and cool and weird stuff because not everything is about growth and dollars."},{"type":"log","id":"2026/01/19","title":"2026-01-19","description":"","tags":["glm","cerebras"],"date":"2026-01-19","url":"/logs/2026/01/19","content":"I just incinerated $10 running GLM 4.7 on Cerebras to try and Ralph a clone of this game I used to play.\nTook about 15 minutes for the balance to go to $0.\nResult, not awesome. Maybe okay.\n\n![Aquarium](images/aquarium.png)\n\nI Claude Coded the game into a playable state with a few more prompts (it was still broken once my balance reached zero).\n\nCerebras was fast but costly given the token throughput.\n\n## Takeaways\n\nThis approach \"works\" in that it builds in the direction of the spec for extended periods of time.\nA browser game might not have been GLM's strength -- the model measures well on coding benchmarks, so some kind of backend task might have been more reasonable to try.\nIt did write a lot of compiling TypeScript though and I didn't give it much to work with in terms of design or aesthetics, so I'll take the blame there as well.\n\nIt seems like building an intuition for managing long running loops and getting good results requires building and experimenting with a lot of long running loops.\nNo big surprise there.\nAnd it's not a cheap thing to learn.\n\n## Code\n\n```sh\n#!/bin/bash\n\n# Simple Ralph Loop\n# Continuously passes plan.md to opencode with the prompt to work the plan\n# Stops when the agent returns \n\nPLAN_FILE=\"${1:-plan.md}\"\nITERATION=0\n\nif [ ! -f \"$PLAN_FILE\" ]; then\n echo \"Error: $PLAN_FILE not found\"\n exit 1\nfi\n\necho \"Starting Ralph loop...\"\necho \"Will continue until agent returns \"\necho \"---\"\n\nwhile true; do\n ITERATION=$((ITERATION + 1))\n echo \"\"\n echo \"=== ITERATION $ITERATION ===\"\n echo \"\"\n\n # Build the prompt: reference the plan file by name\n PROMPT=\"Work the plan in $PLAN_FILE and test until complete. Perform one task at a time. Update the plan file with the completed tasks as you work. When _all_ tasks in $PLAN_FILE are done and tests pass, output to signal completion.\"\n\n # Run opencode with the prompt and capture output\n OUTPUT=$(echo \"$PROMPT\" | opencode run --model cerebras/zai-glm-4.7)\n\n echo \"$OUTPUT\"\n\n # Check if output contains \n if echo \"$OUTPUT\" | grep -q \"\"; then\n echo \"\"\n echo \"=== RALPH COMPLETE ===\"\n echo \"Finished after $ITERATION iteration(s)\"\n exit 0\n fi\n\n echo \"\"\n echo \"--- Iteration $ITERATION complete, starting fresh context ---\"\ndone\n```"},{"type":"log","id":"2026/01/18","title":"2026-01-18","description":"","tags":[],"date":"2026-01-18","url":"/logs/2026/01/18","content":"Running Claude Code on `qwen3-coder:30b` via Ollama does not work."},{"type":"log","id":"2026/01/17","title":"2026-01-17","description":"","tags":[],"date":"2026-01-17","url":"/logs/2026/01/17","content":"> Internal adoption charts have been vertical: ~30% of all pull requests merged to our frontend and backend repos are written by Inspect. It only took a couple months for us to reach this level of usage, and it continues to grow. We didn't force anyone to use Inspect over their own tools. We built to people's needs, created virality loops through letting it work in public spaces, and let the product do the talking.\n\nhttps://builders.ramp.com/post/why-we-built-our-background-agent"},{"type":"log","id":"2026/01/15","title":"2026-01-15","description":"","tags":[],"date":"2026-01-15","url":"/logs/2026/01/15","content":"Experimenting with a personal agent using the file system, SQLite, skills tools via MCP.\nSo many ways to make things work these days.\n\nI'm still exploring but once you know what you want an agent to do, I suspect you'll need robust tests to validate it works and that it continues to work as you evolve it."},{"type":"log","id":"2026/01/12","title":"2026-01-12","description":"","tags":[],"date":"2026-01-12","url":"/logs/2026/01/12","content":"Tried to make a new Github account today and the CAPTCHA was absurd."},{"type":"log","id":"2026/01/06","title":"2026-01-06","description":"","tags":[],"date":"2026-01-06","url":"/logs/2026/01/06","content":"Still enjoying working on Tarn.\n\nI played around with adding some [Hemingway](https://hemingwayapp.com/)-like features.\nI like them to put myself more into editor mode after getting thoughts written down and taking a few revision passes.\n\n---\n\n> It's so hard to describe to somebody like what's different if you just read the summary in the spreadsheet versus you read the whole LinkedIn profile.\n>\n> It's one dimensional or not multi-dimensional.\n\nFrom Dialectic: 35: Brie Wolfson - Loving Attention & Ease in Craft, Jan 6, 2026\nhttps://podcasts.apple.com/us/podcast/dialectic/id1780282402?i=1000743936367&r=626"},{"type":"log","id":"2026/01/05","title":"2026-01-05","description":"","tags":[],"date":"2026-01-05","url":"/logs/2026/01/05","content":"Paul Simon on \"what makes you stuck?\"\n\n> Everywhere I went lead me where I didn't want to be, so I was stuck.\n\nhttps://youtu.be/qFt0cP-klQI?si=XNdG7SkBIeNqCJLN&t=445"},{"type":"log","id":"2026/01/03","title":"2026-01-03","description":"","tags":[],"date":"2026-01-03","url":"/logs/2026/01/03","content":"Agents are increasingly being trusted to do quantities of work that cannot be verified at code-level detail.\nFinding verification criteria for the products of work done like this will be critical for having any amount of trust in it. \n\n---\n\nI still run Tarn out of Xcode because its codebase is very much in flux.\nToday, I finally patched an issue where unsaved file contents got cleared between app restarts.\nI lost the first draft of this log to that issue.\nSlowly but surely, this app is feeling like the best place for me to write stuff.\n\nA few days ago, I used Nano Banana Pro and Apple's [Icon Composer](https://developer.apple.com/icon-composer/) to create an app icon for it.\nThe aim is to be at a point where I have more of a stable release in my app folder soon.\n\n![Tarn Icon](images/tarn-icon.png)"},{"type":"log","id":"2026/01/02","title":"2026-01-02","description":"","tags":[],"date":"2026-01-02","url":"/logs/2026/01/02","content":"I've been playing around with using Voice Activity Detection to record multiple separate audio channels, then stitching those together into a transcript with Whisper to do speech to text.\n\nAgents make ideas so malleable.\nA well articulated idea, or implementation of that idea is in invaluable yet almost completely fungible.\nIf someone explains an idea in detail, an agent can fluently apply it in any context you'd like.\nProducing an artifact with this level of clarity is difficult, but once produced, it can be absorbed and applied broadly nearly instantly by anyone who learns of its existence.\n\n---\n\nI've been trying to reproduce a reference implementation of [Strix](https://timkellogg.me/blog/2025/12/15/strix).\nIn doing so, I am steering Claude Code to read the blog post and then setting up a personal version in my own environment.\nThat is works continues to floor me.\n\nTim's blog post is a sort of genetic code for Strix and when given access to this code, an agent can create another approximate digital incarnation of Strix, based on how Tim has written about it.\nIn the same way ideas could spread rapidly with the invention of the internet, now fully embodied concepts of functioning software can permeate throughout the internet if they are loosely described and defined in words.\nThe more detailed, the more faithful the implementation will be to the original."},{"type":"log","id":"2026/01/01","title":"2026-01-01","description":"","tags":[],"date":"2026-01-01","url":"/logs/2026/01/01","content":"I'm working through my second implementation of an idea that has been bouncing around my head for a while.\nThe general idea is to be able to transcribe a conversation in real time and have an agent read the transcription, turn it into a spec, and then build what is being discussed.\nThe ongoing conversation will steer the agent's work in real time.\n\nI'm not sure if the agent will be fast enough for this to work well but we'll see how it goes."},{"type":"post","id":"2025/year-in-review","title":"Year in Review: 2025","description":"","tags":["year_review"],"date":"2025-12-31T15:00:12.000Z","url":"/posts/2025/year-in-review","content":"This year was another year of wild change in technology and software engineering.\nIt felt like the year flew by yet so much happened during it.\n\nIn 2024, my approach to building software was thoroughly transformed with the release of `claude-3-5-sonnet` and use of Cursor's Chat/Agent to build software.\n\nThe breakneck speed of iteration and improvements did not stop in 2025.\nThis year, I shifted to working more with Claude Code, and most recently `claude-opus-4-5`, but with meaningful improvements along the way from Sonnet 4 to Opus 4.1 to Sonnet 4.5, with some experimentation with Gemini 2.5 Pro and Gemini 3 Pro preview along the way.\n\nIncreasingly, while I have a preferred agent harness and model that I work with, I've found that I can comfortably operate with most leading edge models and most tools to accomplish my goals building software.\nWith an underlying, first principles approach to how an agent harness works and the tools and context it has access to, you can go far.\nThe features and improvements in capabilities continue to increase the ceiling of what is possible.\nClaude 4.5 Opus was yet another improvement in the autonomy and accuracy with which I found I could delegate to a coding agent to accomplish a task I specified.\n\n## Coding with agents is so much fun\n\nI often tell those interested in how I work with agent coding tools that they both allow me to explore an idea to see if it's interesting enough to continue working on while simultaneously serving as a continuous inspiration for me.\nAny idea I can turn into words or text is a jump off point for exploration in code.\nIf something feels like it's working, I get pulled in and see where it takes me.\nThis exploration leads to more learning and ideas and this cycle continues.\n\nI probably spent in excess of 1,000 hours working with coding agents this year and I feel like I am still only scratching the surface of the changes that are to come with regard to how people interact with computers and how computers are used as tools.\nWith the \"old way\" being only 2-3 years in the rear view mirror, my process of building software and using a computer as a tool has continued to change meaningfully every 3-9 months.\n\n## Review of last year's review\n\nIt's hard to appreciate the speed of change while being swept up in it but re-reading last year's review has given me some insight.\n\nReflecting on the aims I set for this year, here is how those manifested in my focus and work.\n\n> - Continue building machine learning foundations\n\nWhile I didn't continue my work on the Fast.AI course, I had the opportunity to use an embeddings model to surface unstructured text in a dataset that previously was unreviewed due to lack of resources.\nMy sense is embeddings continue to be an underappreciated element of the machine learning stack and can go quite far in use for data analysis and semantic search.\nYou don't always need a chatbot - you can just write queries and scripts.\n\n> - Get comfortable with an LLM eval stack\n\nI intentionally did not invest in a particular eval tool.\nIn my work creating a multi-stage, complex document analysis LLM pipeline, my takeaway has been that in many cases, to use an LLM eval tool, you need to transform the shape of your problem into a shape the eval tool accepts.\nGiven the ease with which one can now build bespoke software, I've leaned more heavily into building purpose-specific tools for myself and my team to address our problems specifically, and in a way we can also modify going forward.\nThis has felt like a good tradeoff for the time being.\nAlso, we're not building a chatbot and LLM eval tools seem to heavily index on supporting chatbots.\n\n> - Continue exploring alternate LLM UX through Delta and other experiments\n\nAt the beginning of the year, I had a hotkey setup that would open a browser tab to the Anthropic Workbench.\nMy preference has generally been to try and make direct API calls to LLMs rather than use consumer chat wrappers like Claude.ai and ChatGPT, because I want more direct control of things like the system prompt and don't want my prompts to be influenced by the hidden prompt of the product.\nThe results were better (for what I usually needed), but I was never happy with how slow it felt to load the page in the browser.\nAdditionally, usually my workflow was something like\n\n- copy content\n- hotkey to open the browser\n- sign in if I got booted\n- paste\n- write a prompt\n- submit\n\nAnd this only worked for Claude models.\nIf I wanted to use Gemini or OpenAI models, I had to go to a different playground.\n\nIt was _fine_.\nBut because it was something I do so often, the friction became irritating.\n\nFrom this frustration emerged [Tomo](/projects/tomo), a little Swift app I built with Cursor and Claude Code to call the OpenAI chat compatible APIs and with baked in support for popular model providers.\nThe killer feature for me was hotkey summoning, which allows you to copy text or take a screenshot with hotkeys that also summon the Tomo chat window with the context automatically attached.\nIt fuses my previous workflow together and allows me to stay in flow.\n\nThere is no agent or context integrations.\nIt's light and fast.\nI love it.\n\n> - Engage more with folks working on applying LLMs\n\nThis year I said \"yes\" to far more things and was substantially more proactive about reaching out to folks doing work I thought was interesting.\nI only regret not doing this sooner.\n\nI have several recurring 1:1s with people who are genuinely inspirational to me, and this is a huge motivator and support if I'm finding myself stuck, confused, or lost.\n\n## Migrating my blog\n\nAs I also noted in [last year's review](/posts/2024/2024-year-in-review#redesignrebuild-this-blog), I didn't redesign or rebuild my blog.\nIn 2025, improvements in coding agents made this feel like not as big a burden.\nThis current blog was originally launched as a separate site at https://thoughteddies.com.\nI used Astro to build a handful of interactive posts, using Astro and MDX to embed modern Javascript frameworks in my post content.\nBy July, I was ready to migrate my Hugo site fully and wrote about that [here](/posts/2025/migrating-to-astro).\n\nIn 2024, I avoided this migration because I didn't want to take time away from writing and experimenting.\nIn 2025, the coding-agent-assisted migration was easy enough I didn't even worry about it.\nOne day I woke up with a bit of motivation and energy to do it and that was all it took to see light at the end of the tunnel and make it through.\n\n## Coding agents, ambition, and energy\n\nThe bar for the size and complexity of tasks and projects that coding agents can complete or assist with continues to rise.\nIdeas and projects I might have previously considered writing about can now be realized in an hour or less of prompting.\n\nKnowing I'll be able to rapidly see progress on an idea is usually a great motivator to get started.\nEven though more than ever is doable in a fixed amount of time, there are still limits.\nComplex projects take time, planning, and persistence.\nNot everything can be \"one-shot\" and I suspect this will always remain the case.\nTo build something aligned with your personal vision, you have to explain how it works.\nWith a coding agent, if you don't explain something, the agent will fill it in and since it can't read your mind, you'll likely need to iterate until you get closer to what you personally had in mind.\nYou can figure this out before you start coding or during, but to make the thing you want, you have to externalize your thinking as much as possible so the agent can implement to those specifications.\n\n## Other things I did this year\n\n- Created a [link blog](/posts/2025/create-a-link-blog)\n- Refined my process for teaching others to code with an agent\n- Created a [\"vibes\"](/vibes) site for hosting little one-off apps\n- Created a GitHub activity inspired [`/activity`](/activity) page for this site\n- Wrote a guide on [agent coding strategies](/posts/2025/agent-coding-strategies) midyear that seems to have held up pretty well\n- Experimented with [zoomable documents](/posts/2025/zoomable-document) for progressive disclosure of content\n- Explored [LLM conversation branching](/posts/2025/llm-conversation-branching) with embeddings visualization\n- Built interactive [document citations](/posts/2025/document-citations) using Claude's citation feature\n- Wrote about using [images as context](/posts/2025/images-as-context) for doing design with coding agents\n- Built an Escape Room-influenced, retro computer game with my cousin\n ![Retro game intro](images/escape-lure.png)\n- Built several games, one currently in progress and presently at ~100,000 LOC, 100% coded with Claude Code and Opus 4.5\n\n## Content by the numbers\n\n(Calculated with [this](https://github.com/danielcorin/thought-eddies/blob/main/scripts/year_review.py) script)\n\n| Category | Posts | Words |\n| -------------------------- | ------- | ---------- |\n| [🏗️ Projects](/projects) | 2 | 525 |\n| [📖 Posts](/posts) | 20 | 28,227 |\n| [🌱 Garden](/garden) | 1 | 615 |\n| [✏️ Logs](/logs) | 104 | 16,327 |\n| [📝 Today I Learned](/til) | 22 | 18,822 |\n| **Total** | **149** | **64,516** |\n\n## Things I aim to focus on more next year\n\n- Getting more structured about my process for working with agents and how I teach others to use them\n- Experimenting with personal content curation for myself, using RSS feeds\n- Possibly sharing the game I've been working on\n- Experiment more with local, open source models for coding"},{"type":"log","id":"2025/12/31","title":"2025-12-31","description":"","tags":[],"date":"2025-12-31","url":"/logs/2025/12/31","content":"I'm not sure if they originated this pattern but I like how Claude Code introduces new features with tips.\n\n```text\n✻ Whirring… (esc to interrupt · thinking)\n ⎿ Tip: Start with 'btw' to ask a quick side question\n without interrupting Claude's current work\n```\n\nI tried this one out and it didn't feel better than opening another `claude`.\nIt seems to have the existing conversation context, which is helpful, but the question doesn't seem to be enqueued immediately and waits for the previous prompt to complete, so I don't love that.\nMy ideal behavior would be to fork the conversation and run the `btw` prompt in parallel.\n\nSomeone told me `amp` has threads and maybe those do that."},{"type":"log","id":"2025/12/29","title":"2025-12-29","description":"","tags":[],"date":"2025-12-29","url":"/logs/2025/12/29","content":"Notes on way too many hours spent agent coding over the holidays.\n\n![Claude Holiday](images/claude-holiday.png)\n\n- Claude Opus 4.5 running in Claude Code is a workhorse. It hardly ever got stuck in the stacks I was working in (SwiftUI with HTML/CSS/JS in a WebView and a TypeScript 2D Canvas game).\n- My ideas will move faster than the agent can. I found myself starting additional `claude` instances to work on smaller fixes and features I intuited wouldn't overlap with the work the \"main\" agent was doing. This allowed me to get more things done even while I was poking around with the agent working on more complicated features and refining rough edges.\n- If the agent is struggling, `ultrathink` can help in a pinch. It's also as good or better to plan a feature up front with `ultrathink`. Hard to compare the two but it's a nice thing to have in your bag.\n- Claude Code has gotten excellent at structuring and/or searching projects so it can find existing implementations rather than creating duplicate implementations. This was a problem several months back which created a \"point of no return\" for fully agent coded projects, where the agents couldn't search or understand a project well enough to code its way out of problems. I'm sure there is a max codebase size where these agents can be effective, but I've had great success on projects of 10k and 100k lines. It's worth noting the speed of the agent per prompt decreases as lines of code increases. The agent spends more time searching existing files in larger codebases. This seems to be what allows it to continue to implement successfully, and seems to be an unavoidable part of the physics of growing codebases (and was before coding agents were a thing too).\n- I ran into one weird set of Swift warnings where Claude Code kept undoing and redoing two approaches, neither of which eliminated all warnings. GPT-5.2 in Cursor managed to resolve this one.\n- My intuition is still necessary. When working on a feature that required a text editor in a Swift app, Claude tried several open source editors and none quite fit the way I wanted them to. I explicitly told Claude to use the [Monaco](https://microsoft.github.io/monaco-editor/) text editor (the core of VS Code) because I have an affinity for it.\n- Sometimes the agent knows better than me. The agent is great at following directions and sometimes that means it will try to do things it shouldn't. This has improved since past model iterations but if an approach isn't working and I give the agent leeway to try a different approach, often I am pleasantly surprised by the idea and adopt something like it.\n- Vision is indispensable. Software is an incredibly flexible canvas and the agent will give you a decent implementation of whatever you ask for, but if you don't ask for something or have a rough idea you're trying to implement, you will get lost in the slop.\n- For fun, personal projects, I start by doing a voice-to-text brain dump of the idea in a `dump.md` file. Then I prompt the agent to make a `spec.md` from these raw thoughts. I read and refine that, then have it start implementing. I use fresh context windows for each of these tasks.\n- By the end of the holiday, I was working on two or sometimes three projects in parallel. I don't think this is a particularly desirable thing to do, but otherwise I found I was waiting for the agent to finish and had the thought to do something else.\n- Agent coding is entrancing and addicting for me, far more than writing software by hand ever was. The feedback loop for writing a prompt and getting what you asked for is tight and the agents are really good at following instructions.\n- Polish is always needed. I'm continually reminded of an interview [Ryo Lu gave](/logs/2025/12/21) where he said \"You always start with slop, with AI\". I agree. When I am prompting, it's quite rare the first draft with AI is exactly what I want; it's the first draft. From the starting point, I play with the implementation and buff away the rough edges and tweak and tease out the experience or implementation I had in mind. Because of this, metaphors like \"sculpting\", \"raising\", \"chiseling\", and \"molding\" software resonate for me. The process is completely different than typing out all the characters. You throw a hunk of clay on the table and then start removing, shaping, and adding new things. It's as much exploration as execution or implementation and the journey and the wrong turns are instructive for how you find the path you prefer."},{"type":"log","id":"2025/12/28","title":"2025-12-28","description":"","tags":[],"date":"2025-12-28","url":"/logs/2025/12/28","content":"I am working on adding a feature to Tarn where I can type `@@` and it will pop a list of content in my blog I can link to in markdown style.\nThis is an idea borrowed from Obsidian for easily reference external content or ideas.\n\n---\n\nI adore [this site design](https://schpet.com/notebook).\n\n---\n\n> be curious about great ideas and engage with them\n\nFrom AI & I: Best of the Pod: Reid Hoffman on How AI Is Answering Our Biggest Questions, Dec 24, 2025\nhttps://podcasts.apple.com/us/podcast/ai-i/id1719789201?i=1000742605641&r=3610"},{"type":"project","id":"tarn","title":"Tarn (2025)","description":"","tags":[],"date":"2025-12-27T22:13:02.450Z","url":"/projects/tarn","content":"I was recently taken with this article on [Perfect Software](https://outofdesk.netlify.app/blog/perfect-software).\n\n> Perfect software isn't the best software. It's perfect simply because it does exactly what you want, how you want it, when you want it.\n\nOver time my process for writing and building things has evolved, but the step function changes have usually occurred with changes in my process.\n\nI started writing more consistently because I made it easier for myself to write.\n\nThis lack of success, of course, makes sense if you appreciate that one's process is unique.\nI've long wanted to find a better tool ideas and writing for my process but never found the right thing.\nWith that recognition, I've embarked upon a journey to create my own tool to write and work on this blog and explore ideas. My plan is to mold it into whatever I need it to be.\n\n> The Extended Mind Theory argues that our tools are not just accessories, but literal extensions of our cognitive process. Viewed this way, a generic tool like a one-size-fits-all app, feels like a prosthetic that doesn't quite fit.\n\nTarn is heavily influenced and inspired by VS Code, but is built and Swift and designed for specifically my processes.\nIt has configuration or settings pane.\nIt is hardcoded to behave the way I want it to\nIf I want it's behavior to change, I change the software itself.\nI do this with agent coding tools like Claude Code.\n\nThe main UI\n\n![Tarn UI](images/tarn-ui.png)\n\nZen Mode\n\n![Zen Mode](images/zen-mode.png)"},{"type":"log","id":"2025/12/27","title":"2025-12-27","description":"","tags":[],"date":"2025-12-27","url":"/logs/2025/12/27","content":"After hitting my head against a few different open source Swift text editor implementations, I ended up settling on a webview with a Monaco in the Swift app.\nThe syntax highlighting isn't exactly how I want but if in reality, this has changed for me several times over the years as I've moved between tools and I'll probably get over it.\n\nI've gotten really pulled into building this thing, inspired by [Perfect Software](https://outofdesk.netlify.app/blog/perfect-software), because I've started to see all the little ways in which I can make it mine, in a way that is hard to accomplish with commercial software.\nWith open source software, you can fork, but you inherit the whole project rather than the bits and pieces you want.\nTo me, it feels like the average personal software is going to be simpler than that.\n\nOn a different note, I think I've gotten pulled so far into this because coding agents (Claude Code) make it so easy (addicting?) to do _just one more thing_.\nI've been doing one more thing for two days now.\n\nThat said, I do have something to show for it.\nWe see if it sticks."},{"type":"log","id":"2025/12/26","title":"2025-12-26","description":"","tags":[],"date":"2025-12-26","url":"/logs/2025/12/26","content":"I've been working with Claude Code to build a tool to help me write in this blog.\nI've historically used Cursor to write in MDX and Claude Code to help build and wire up custom Astro and sometimes React components to add interactivity to posts.\n\nThere are a few rough edges though.\nMy content scaffolds are Python scripts, which are not quite as fluid as I'd prefer.\nMy image optimization process is kludgy.\nMy content importing processes (currently experimenting with [Drafts](https://getdrafts.com/)) is still a work in progress.\n\nVS Code and Cursor have brought me a long way, but there really is no substitute to having more control over the tools you use everyday.\nIf you want something, you can build it.\nThis is what I am attempting now with `Tarn`."},{"type":"log","id":"2025/12/25","title":"2025-12-25","description":"","tags":[],"date":"2025-12-25","url":"/logs/2025/12/25","content":"I've seen coding agents refuse or avoid writing comprehensive tests because they claim \"most tests are passing\" or \"90% is great coverage\" even when prompted to do something like \"fix the tests\" or \"add tests covering 100%\".\nUnlike when prompted to code something, it seems when prompted to test things, agents are kind of lazy.\nI wonder if this specifically correlates with how easy it is to reward hack passing tests.\nGetting 100% unit coverage is notoriously irritating.\nThere are substantial diminishing returns and the final few percent usually come down to covering lines that bear almost no impact on ensuring the system continues working as designed.\nThus, I'm speculating agents struggle to do this because most people can't be bothered to either.\n\nOr possibly it's because tests test code, thus models can write code, have it validated, and be reinformed to do better.\nBut I can't ever remember seeing anyone write code to test tests."},{"type":"log","id":"2025/12/24","title":"2025-12-24","description":"","tags":["claude-code","nix"],"date":"2025-12-24","url":"/logs/2025/12/24","content":"I probably would have switched off of Nix for system management, but with Claude Code, any problems I run into are as good as solved."},{"type":"log","id":"2025/12/21","title":"2025-12-21","description":"","tags":[],"date":"2025-12-21","url":"/logs/2025/12/21","content":"> That part of it though, I think is where, for lack of more precise language, people get stuck. It's like, again, I watch you use Cursor, it's like you're literally, it's like you're just nudging the model. And your prompts are not, yeah, it's that demeanor for the listeners.\n>\n> You're just poking it. It's not these long specs. I'm watching you just be like, can you come up with an app idea?\n\nFrom Dialectic: 34: Ryo Lu - It's All the Same Thing, Dec 18, 2025\nhttps://podcasts.apple.com/us/podcast/dialectic/id1780282402?i=1000741808474&r=2988\n\n---\n\n> You just need to put your soul in this. You need to care about every detail. You need to not accept whatever purple gradient the AI gave you is the end.\n>\n> Like that is just the beginning. You always start with shit. You always start with slop, with AI.\n>\n> And then you refine it, you make it better.\n>\n> That's the beginning, not the end.\n\nFrom Dialectic: 34: Ryo Lu - It's All the Same Thing, Dec 18, 2025\nhttps://podcasts.apple.com/us/podcast/dialectic/id1780282402?i=1000741808474&r=5060\n\n---\n\n> AI models are trained on all the public knowledge, information and the code that I can see.\n>\n> And you are trained on the same thing. Like all the books you've read, all the fonts that you know, all the artists that you admire, the world around you. And you build that intuition or taste or whatever.\n>\n> And you start forming an opinion about how you want to shape the world.\n>\n> And you express it by building.\n\nFrom Dialectic: 34: Ryo Lu - It's All the Same Thing, Dec 18, 2025\nhttps://podcasts.apple.com/us/podcast/dialectic/id1780282402?i=1000741808474&r=5133"},{"type":"log","id":"2025/12/18","title":"2025-12-18","description":"","tags":[],"date":"2025-12-18","url":"/logs/2025/12/18","content":"In pushing the envelop in building a large project likely with a coding agent, I am coming around to the need for a structured task management system, whether it be Linear or `beads` or similar."},{"type":"log","id":"2025/12/17","title":"2025-12-17","description":"","tags":["tokenization"],"date":"2025-12-17","url":"/logs/2025/12/17","content":"I commonly use an `and/or` approach when writing, both for people and language models.\nAt some point (I can't remember exactly when), I switched to doing the following, for language models only:\n\n> and / or\n\nThe reasoning in my head was this would tokenize more clearly to the model.\nToday, I checked the [OpenAI tokenizer](https://platform.openai.com/tokenizer) and kind of think I confirmed this thought process.\nI'm still not quite sure though, since very few people would actually write this way in the source texts on which models have been trained.\n\nThat said, I have seen tokenization tricks work for helping models to solve certain problems, like a Wordle puzzle or [counting the letters in a word](/til/dspy/intro).\n\nIf you know anything about how this works, let me know!\n\n![And / Or Tokenization](images/and_or.png)\n\n---\n\nA fun thing about this post - I had Claude Code find the post I wrote about counting letters in a word with LLMs and link it above with the prompt below.\nI'm going to be using this trick more often.\n\n> '/Users/danielcorin/dev/lab/thought-eddies/src/content/logs/2025/12/17/index.mdx'\n> \"counting the letters in a word\" find if I wrote about this and link to it"},{"type":"log","id":"2025/12/15","title":"2025-12-15","description":"","tags":["amp","cloudflare","durable-objects"],"date":"2025-12-15","url":"/logs/2025/12/15","content":"I used [`amp`](https://ampcode.com) to create a multi-client, single-server real-time websocket application using [Cloudflare Durable Objects](https://developers.cloudflare.com/durable-objects/).\nIt went quite well.\n\nI wasn't expecting `amp` to take so many actions on my behalf without permission.\nIt deployed the site after the first prompt since `wrangler` was already configured on my system.\n\nCool, but also I don't think I'm ready for that level of full-send, having seen a \"Claude Code `rm -rf`'d my home directory\" article yesterday."},{"type":"log","id":"2025/12/12","title":"2025-12-12","description":"","tags":[],"date":"2025-12-12","url":"/logs/2025/12/12","content":"I share Simon's sentiment on my the [skills](https://simonwillison.net/2025/Dec/12/openai-skills/) ideas.\nI've gone even more unstructured - I usually start little ideas and projects with an agent (Claude Code) and a markdown file, then add scripts and data as needed to see how far I can get."},{"type":"log","id":"2025/12/10","title":"2025-12-10","description":"","tags":["tools"],"date":"2025-12-10","url":"/logs/2025/12/10","content":"Added a [tools](https://tools.danielcorin.com/) page to this site, inspired by [Simon's recent post](https://simonwillison.net/2025/Dec/10/html-tools/)"},{"type":"log","id":"2025/12/07","title":"2025-12-07","description":"","tags":[],"date":"2025-12-07","url":"/logs/2025/12/07","content":"[This attempt](https://j0nah.com/i-failed-to-recreate-the-1996-space-jam-website-with-claude) to recreate the 1996 Space Jam website with Claude caught my attention because I've also been running into issues where Claude cannot reproduce code from images faithfully.\nIt's much better (right now) when you give specifications in language."},{"type":"post","id":"2025/images-as-context","title":"Images as Context","description":"","tags":["context","multi-modal"],"date":"2025-12-06T15:00:12.000Z","url":"/posts/2025/images-as-context","content":"import ChatContainer from '@components/prose/ChatContainer.astro';\nimport ChatMessage from '@components/prose/ChatMessage.astro';\nimport windowImage from './images/window.png';\nimport modernOsImage from './images/modern-os.png';\n\nimport Opus45 from './components/opus-4.5.astro';\nimport Gemini3Preview from './components/gemini-3-preview.astro';\nimport Gemini3PreviewDetails from './components/gemini-3-preview-details.astro';\n\nWorking with coding agents has been a dance of context management.\nThese days, if an agent loop isn't producing the result I want, it's more often than not a problem of context rather than a shortcoming of the language model or agent scaffold/harness.\n\nBecause of this, I've started thinking about context as the object of value in building software and doing things with a computer.\nOf all the ideas that exist in the universe, the context you are working with provides the directional leanings for the problem you are dealing with and the implicit shape a solution could take.\n\nContext also comes with a variety of information densities.\nThis week, I tried to provide the [Macintosh Human Interface Guidelines](https://dn721903.ca.archive.org/0/items/apple-hig/Macintosh_HIG_1992.pdf) from 1992 as context to Claude Code to coax out a CSS library that would allow me to style a website with the design patterns from Mac OS 9.\nAfter chopping up the 400+ page PDF into single-page PDFs, Claude Code navigated these pages via the table of contents it found on one of those pages, then created a markdown file with its findings from the design.\n\nThe results were far from pixel perfect, but the concept, that context can be grouped, refined, transformed, and carried around between agents crystallized for me from the experiment.\n\nMy working thesis is the agent struggled to implement pixel perfect design, not because it can't, but because I hadn't provided it a well defined design specification.\nAnd what I had provided had relatively low information signal to solve that problem.\n\nHowever, if I were to refine a design specification out of this more diluted context, that could become a high information density piece of context that would be portable to communicate the idea with clarity to any agent in the context of any problem I was trying to solve using this design system.\n\n## The image problem\n\nThe context problem is not quite that simple though.\n\nWhen it comes to reproducing something in code, an image is rarely enough to get a pixel perfect design.\nWhereas language descriptions, especially those with specific measurements, seem to get better results.\n\nI'm not the only one who has [noticed this behavior](https://j0nah.com/i-failed-to-recreate-the-1996-space-jam-website-with-claude).\n\nHere's a straightforward example I tried for this screenshot of a text document in Mac OS 9, prompting `claude-opus-4-5-20251101`.\n\n\n \n given the provided image of the text editor in mac os 9, output a pixel perfect reproduction in html and css\n\n \"A\n\n \n\n\nHere's `claude-opus-4-5-20251101`'s output.\n\n\n\nHere is `gemini-3-pro-preview`'s output.\n\n\n\nI chose these specific models because they are the top performing models on [DesignArena](https://www.designarena.ai/).\n\nBoth results are obviously inspired by the source image, but also not close to pixel perfect.\nAnd I suspect we're not exactly starting from zero-knowledge in this case.\nThese models know roughly what Mac OS 9 looks like and can describe it in language:\n\n> ...\n> Key Visual Elements\n>\n> Window Design\n>\n> - **Light gray** textured backgrounds with subtle horizontal pinstripes\n> - Rounded rectangular title bars with a **striped/ridged texture**\n> ...\n\nAt least in broad strokes.\n\nWhile I give Gemini credit for doing the best job I've seen on this particular task by a language model, it's still not close to a pixel perfect reproduction.\n\n## Words work better\n\nSo how do we do better?\nWe could modify the image to annotate focus points for the model, but the image is _what we want_.\nThe model just isn't quite giving it to us.\n\nSo what can we do?\nWe can use words.\n\n\n \n given the provided image of the text editor in mac os 9, output a pixel perfect reproduction in html and css. take particular care in crafting the buttons in the top right corner. these are not modern operating system buttons. the right most has two black horizontal lines going through the center with a small gap between them. the button to the left of that has the upper left hand quadrant outlined in black. be sure to get these buttons pixel perfect to the description.\n\n \"A\n\n \n\n\nWith Gemini 3 Pro Preview, we get this:\n\n\n\nNot exactly right, but meaningfully closer (as far as the buttons are concerned).\nThe words help get the model closer to the desired result.\nThis is the pattern we've become familiar with when working with coding agents.\n\nThe image alone is not quite sufficient to get the desired output.\nWe need to follow up with words to improve clarity if we want pixel perfect.\n\nThis recognition is informative because it suggests that text-based representations of concepts are more effective for getting models to produce the desired output in code.\nText provides an easier means to steer incorrect output and seems to capture a specification more losslessly and portably than an image.\n\nSince we're looking for language-like output, language input seems to be the most effective way to steer.\nIn the case of an image model, like [Nano Banana Pro](https://deepmind.google/models/gemini-image/pro/), if you want a near pixel perfect reproduction of an image in a modified environment, you just give the model the image.\n\n\n \n place the provided image of the text editor in mac os 9 in a hyper modern operating system of the future in 2095. keep the provided window design and buttons pixel perfect.\n\n \"A\n\n \n \n \"A\n \n\n\nNote: the model still isn't quite perfect as it adds disabled arrows on the horizontal scrollbar that aren't there in the original image.\n\nIf you want an image, give an image.\nIf you want text, give text.\n\nThe state of the art in both areas is quite good.\n\n## Images are helpful but not (yet) sufficient context to produce code\n\nImages are pixels on a screen.\nIf you want to introduce a new visual element to an image, you work in these pixels and these pixels alone.\nAt least, until models start creating images with layers.\n\nTo reproduce an image as a website, a translation of the image into code that a browser renders is necessary.\nThat feels a lot more complicated to me.\n\nIt's possible this is, in a way, a data problem.\nBased on my research, there aren't that many attempts to reimplement the Mac OS 9 design system on the web.\nIf there were, the model could probably execute this task without issue, roughly reproducing from example projects.\n\nThe models' failures seem like failures to generalize for some edge cases.\nMac OS 9 button icons are unusual looking.\nNothing uses these today.\nThe UI pattern did not endure.\n\nA model can be prompted with words to reproduce button designs like this.\nBut they balk when asked to describe or reproduce it themselves given the image alone or even just the concept, e.g. \"describe the two buttons in the top right corner of the windows in the Mac OS 9 Platinum UI\".\nThey just don't seem to really know what they are the way they seem to know about other things in depth.\n\nThis challenge continues to be an interesting one that shows up as I attempt to transform ideas from context into different code projects."},{"type":"log","id":"2025/12/05","title":"2025-12-05","description":"","tags":[],"date":"2025-12-05","url":"/logs/2025/12/05","content":"Figuring out how to teach someone how to use an agent continues to be a problem I only know how to solve by pairing with someone."},{"type":"log","id":"2025/12/04","title":"2025-12-04","description":"","tags":["tomo"],"date":"2025-12-04","url":"/logs/2025/12/04","content":"I did a release of [Tomo](https://www.wvlen.llc/apps/tomo) today for the first time in a while.\nDealt with an annoying scrollbar issue and added conversation exporting which I've wanted for a while.\nThe exported folder becomes helpful input context to an agent when I use Tomo to do a side task then bring back what I learned into the agent session."},{"type":"log","id":"2025/12/03","title":"2025-12-03","description":"","tags":[],"date":"2025-12-03","url":"/logs/2025/12/03","content":"import Sidenote from '@components/prose/Sidenote.astro';\n\nI made a `Sidenote` Astro component, inspired by [Tufte CSS](https://edwardtufte.github.io/tufte-css/).\n\nOn wide screens, sidenotes appear in the right margin and start visible by default. The dotted underline indicates text with an associated sidenote. You can click the dotted text to toggle the sidenote's visibility with a smooth fade animation. When sidenotes are hidden, other visible sidenotes reposition to stay close to their reference text. Hovering over either the dotted text or the sidenote box highlights both and shows their connection. On narrow screens, clicking the dotted underlined text reveals the note inline with the same smooth fade animation. It works like this!\n\nMarkdown provides native support for numbered footnotes[^1], but this approach never quite sat well with me.\nI like having the additional context available in visual proximity to the text that references it. I want to be able to see both at the same time. Jumping between the two takes me out of the flow of reading. Putting the note in the margin allows me to see and read it if I want, but doesn't interrupt the flow of the text and it's still easy to move past if I so choose.\n\n[^1]: Like this!"},{"type":"post","id":"2025/on-writing-speaking-and-thinking","title":"On Writing, Speaking and Thinking","description":"","tags":[],"date":"2025-12-02T21:35:45.000Z","url":"/posts/2025/on-writing-speaking-and-thinking","content":"Have you ever observed someone try and demonstrate how they use a coding agent?\nThe presenter will usually introduce the concept of an agent, discuss the idea of a software harness wrapping a language model, and then will show an example of how it works.\n\nWhen they make the transition from explaining to demonstrating, a visceral change occurs.\nThey begin dictating what they are typing into the agent chat window.\n\n> Create a React, Typescript application, using the Tailwind CSS framework ...\n\nUsually monotone.\nUsually with a slower cadence than their natural speaking speed.\nUsually completely different from how they were previously addressing the audience.\n\nThe communication style is completely different.\n\nFrequently witnessing this shift in these presentations was what first gave me more insight into the differences between writing and speaking, and why I think I better understand this idea now, after being introduced to it by [Paul Graham](https://paulgraham.com/writes.html).\n\n## The tension of writing while speaking\n\nThe reason I believe it is awkward to type a prompt to an agent while presenting is because you're stretching your mental bandwidth trying to perform two different activities at once.\nOn one side, you're presenting or performing.\nYou're trying to deliver certain material to an audience that they can follow and understand.\nYou're thinking about your tone, pacing, and ensuring you've mentioned all your talking points.\n\nOn the other, you're attempting to craft a specific thought.\nBecause you're putting words to an idea, you now need to pick the words.\nYour mind shifts to considering which words you should choose.\n\nIt seems this mental shift also causes most people to downshift in speed.\nFrom what I have observed, it seems\n\n1. most people type more slowly than they speak\n2. putting words on a \"page\" invokes an inner critic in a way that is less common while speaking\n\nBut the disconnect is actually deeper than this.\n\nAs a presenter, you already know what you're going to say, and the change in speed is due to typing more slowly than you speak.\nIf you've preemptively come up with your prompt, writing it or pasting it into the agent is not really representative of the process you followed to create that prompt.\n\nWitnessing either feels unnatural and confusing to an audience member.\nYou are showing the final product of your thinking process, not the process itself.\n\nA better version of this demo would be building an under-prescribed idea in real time and working through the ambiguities and clarifications required to get a functional result.\n\nEffectively using an agent to help you accomplish tasks requires you to participate in the thinking process.\n\n## Thinking is refining unstructured ideas\n\nWriting lets you spend time refining and organizing unstructured thoughts.\nWe can think of unstructured thoughts as stream of consciousness.\nThe type of things you say as a response in conversation or doing morning pages, where you just write and don't edit or delete anything.\n\nThe words and ideas that come from these processes often contain the raw material you might use to refine your thoughts, but they are scattered and fuzzy, lacking coherence and consistency.\nIf want to clearly communicate an idea, you need to refine these.\n\nAnd how do you do that?\nYou put them into words then edit and structure them.\n\nThe writing process brings clarity to thought.\nWriting is thinking.\n\n## Why speaking isn't really thinking\n\nThink of a time you were having a debate and felt like someone said something you didn't quite have a good response to.\nYou felt unprepared and maybe gave an unconvincing response or maybe tried to change the subject to deflect from that fact.\n\nLater, you probably thought of a response that would have been better, you just hadn't thought of it in the moment.\n\nSpeaking is linear.\n\nIf you want to go revisit something you've already said, you must pivot a conversation back to an earlier point.\nTo reopen, revise, or revisit a matter that seemed settled.\nTo bring your conversation partner or audience along to ensure they are following you through the change in topic.\n\nNon-linearity in speaking is an illusion.\nYou are always appending words to the transcript of time.\n\nWhen speaking, you're confined to the best you can do in the moment, given the constraints.\nIf you can't think of the perfect word, you might substitute a passable replacement.\nYou might use several words to describe your idea.\nYou likely won't pause in silence while you think of the right word.\n\nSpeaking uses mental bandwidth you might have allocated to thinking.\nWhen you start saying words, you only have so much time before you need to say other words.\nThat is just how speaking works.\nYou're freestyling your abstract thoughts.\nIt's hard to say things exactly as you want given these constraints.\n\nIf you need to communicate yourself clearly through speech, you probably will prepare and practice beforehand.\nYou'll structure and organize your thoughts.\nYou will consider your argument, counterarguments, and your audience.\nWhen you speak your ideas, you will have already done most of your thinking and can focus on delivery.\n\nIn conversation, you never quite know what your conversation partner will say.\nYou spend mental bandwidth listening and processing what the other person is saying.\nWhen it's your turn to speak, you will have just finished hearing the thoughts of your partner and then you need to verbalize your own thoughts to respond.\n\nHow can you listen, think, and figure out what you're going to say all at once?\n\nAt best, your mental bandwidth is split.\nIn practice, you are reacting.\nWith practice and the preparation of experience, you respond coherently and clearly.\nBut it's hard to imagine doing your best thinking under such tight mental constraints.\n\n## Writing is nonlinear\n\nYour best idea is unlikely to be your first idea.\nYour clearest thought is unlikely to be your first.\n\nIt's challenging and effortful to think things through.\nIt's often complicated, requires research, presents tradeoffs.\nMost things are complicated if you take the time to look at them closely.\n\nWriting is a better fit than speaking for thinking because writing allows for nonlinear interaction with ideas.\nWith thoughts laid out in words, you can fluidly jump between paragraphs, reorder how concepts are introduced, swoop in and change a single word or phrase for clarity.\n\nYou can sit with your work, take breaks when you're tired, and return when you are inspired.\nYou can evolve and define your ideas.\nYou think.\n\n## Writing changes your ideas\n\nWriting is thinking because when you write about something, your ideas change with the writing.\nYou are a slightly different person at the end of writing a work than you were before.\n\nWriting needs to be focused, in part, to ensure you can actually stop writing.\nTo provide a reasonable spot to conclude work.\n\nThe writing that feels most worthwhile leaves me with as many new questions as answers.\n\nYet this always means a writer is cursed to spend forever chasing their tail, writing to think, writing to think.\n\n## Writing and agents\n\nWhen working with agents, the most common difficulty I hear when someone feels they are not having success is that the agent is failing to do what they want it to do.\nTypically, this challenge results from not having done the necessary thinking about what is to be done.\n\nKnowing what you want is the only way to collaborate successfully with a coding agent.\nThese tools are trained to be instruction following.\nIn a void of instructions, they often make median, flavorless decisions.\nIn a void of context, they attempt to fill in the gaps as best they can.\n\nContext engineering (a topic worthy of its own post) is a downstream application of knowing what you want.\n\nYou can only begin to know what you want by thinking about what it is you need to accomplish.\n\nYou write to do this thinking.\nAs you write more, you think more and refine your approach.\n\nSo if you are struggling getting a coding agent to do what you want, think about what it is that you want to accomplish.\nWrite it down.\n\nOnce you're finished, you will have done your thinking and you will have written your prompt as well."},{"type":"log","id":"2025/12/02","title":"2025-12-02","description":"","tags":[],"date":"2025-12-02","url":"/logs/2025/12/02","content":"I always turn off Cursor Tab when I am writing to think.\nOtherwise, I end up subconsciously influenced to write what Cursor Tab thinks I am writing, not what I actually mean to write."},{"type":"log","id":"2025/12/01","title":"2025-12-01","description":"","tags":[],"date":"2025-12-01","url":"/logs/2025/12/01","content":"Lately, I've been thinking about the difference and similarities between speaking, writing and thinking.\nPaul Graham wrote an article about [how writing is thinking](https://paulgraham.com/writes.html) and that if you think you're thinking without writing, you only _think_ you're thinking.\n\nI haven't known what to do with this idea for a while but think I've found something interesting recently.\n\nIn using LLM agents to build software, sometimes I use voice to text functionality to get thoughts out of my head as fast as possible.\nFrom a pure speed perspective, this is usually the fastest way to get the agent something to start working on.\nIn practice, however, the transcription of what I've said isn't always as exacting or precise as what I had in mind.\n\nI _think_ the appreciation of this freestyle nature is to appreciate what it is to think through writing.\n\nWhen you speak to communicate, you're generally trying to communicate some information.\nBut speaking has certain constraints.\nWhile you're speaking, you need to figure out what you're going to say next while you're saying the thing you're already saying.\n\nThis is quite different from writing.\nOddly enough, I never realized how different this was until I watched a bunch of people demonstrate how they use coding agents.\n\nThey would talk about their process, explain what they were going to do, and then would start typing to the agent, at which point, their verbal speed and cadence would change entirely.\n\nThey would dictate or type things like the following:\n\n> Create a React, Typescript application, using the Tailwind CSS framework ...\n\nUsually monotone.\nUsually slower than natural speaking speed.\nUsually completely different from how the presenter was previously addressing the audience.\n\nIn a presentation forum, this is highly unnatural to listen to.\n\nIt's the conversion of the writing process into something consumable to a speaking presentation format, but it's awkward.\n\nHaving noticed how strange this transition feels, when I do presentation coding with agents now, I tend to prefer a voice to text approach.\nThis approach allows me to fluidly explain myself to the audience and the agent at the same time, whenever I want to, by recording myself when I am talking about what I am going to build and using that transcription as my prompt.\n\nThat's a fun party trick, but back to writing and thinking.\n\nWriting slows you down to a speed where you can care more about where you are going.\nThe constraints of speaking require tradeoffs you don't have to make when writing.\n\nIf you can't think of quite the right word to describe what you're thinking, you can fall back to a more simple description or a synonym.\nThis works in conversation, but is a more lossy version of your actual thought and what you were trying to say.\n\nWords and speech are already lossy, but when we take time to write something down, we have the best chance of using the best words we know how to communicate what we mean.\n\nWhen we consider what this means in the context of writing to think, we might suggest speaking is insufficient to think because it requires mental energy to be committed to other things as well.\nIf you're presenting, you may be considering your cadence, your body language, your tone, your volume.\nYou may be watching the audience and picking up on cues from them to get a sense of how they are receiving what you are saying.\nIf you're conversing, you're listening to your conversation partner and picking up similar cues.\nIn the end, what I think this means is that your mental bandwidth cannot be maximally focused on thinking when you are speaking.\n\nThere are too many other things going on.\nMaybe the closest thing to writing when speaking is to record yourself by yourself with no conversation partner and nothing to distract you.\nBut even still, it's not quite like writing.\nYou're looking around, absorbing other stimuli, and subconsciously incorporating it in what you say.\n\nIf you close your eyes and dictate, you might come close to thinking like writing, but you still can't avoid the constraint of being forced to pick the next word to string it together with the last.\nUnless of course, you are going to pause and deliberately and carefully pick each. and. every. word. as. you. say. it. aloud.\nBut is that really even speaking?\n\nThere is a sort of freestyle component to speaking.\nIn our minds, we might think we generally know where we're going (what point we're going to make) but we don't always know how we're going to get there.\n\nI've played with this idea a lot lately.\n\nThe next time you're in a casual conversation, observe the topic and listen to the participants.\nGet a sense of what is being talked about and stay engaged.\n\nSee if you notice multiple threads of conversation.\nSee if it seems like the people speaking are understanding each other.\nSee if you can follow the conversation evolving from one topic to another.\n\nConversations are rarely planned.\nThey emerge, evolve, and eventually fade away.\n\nEven after an engaging and enjoyable conversation, there is a moment of palpable exhale where you realize it's time to turn the page.\n\nSo what are we doing when we converse?\nAre we thinking?\n\nIf we need more of our mental bandwidth to focus fully, then maybe we're thinking to a certain degree but at a diminished capacity.\n\nIf we're debating, we'll hear the argument of our opponent and then be expected to respond, advocating for our perspective over theirs.\nWe're thinking on our feet, but maybe not as deeply or clearly as we're capable of doing.\n\nWe're kind of thinking, but really we're reacting.\nWe've practiced debating and when we hear an argument we only have so much time to respond.\nThere are lots of techniques you could use to buy time.\n\nTake a deep breath. Pause. Vamp. Talk about something unrelated.\n\nAll to buy time.\nTime to think.\n\nBecause when speaking, time is the tightest constraint limiting the clear communication of your ideas.\n\nWhen speaking, it's more difficult to manage a conversation.\nHarder to retrace to previous topics.\nTo prune earlier branches.\nWith a partner it's nearly impossible and would likely make the conversation feel quite unnatural.\n\nThere is a natural give and take of a conversation.\nIf someone is talking about their day, it would be unbecoming to interrupt or abruptly change the topic to something else.\n\nWhen speaking, you live in the flow of time.\nYou need to speak words in an order that make sense.\nYou can't return to a sentence from 5 minutes ago, edit that, then reorganize it to better state your point.\nWhen speaking you kind of can, but it takes practice and you have to expend energy bringing your partner or audience with you.\n\n> I know I said that you can think when you speak but I don't think I said that quite right. What I mean was, you can do an _approximation_ of thinking while speaking but to truly think with clarity you must write.\n\nIf you say that, people can follow what you're talking about, but you have to lay a trail of breadcrumbs.\nWhen writing, the thoughts are more pure and uninterrupted.\n\nIf you have the thought that leads to speaking the quote -- maybe something like\n\n> My point is that writing is thinking and speaking isn't quite thinking so I need to ensure I communicate clearly that speaking isn't quite clear thinking\n\nYou can change your prose to reflect that.\nYou don't need to bring anyone along with you.\nYou don't have to justify your hard pivot.\nYou can think and respond to your thought alone without the decorum or ceremony required when speaking.\n\nTo respond to this thought while speaking compared to writing requires different orders of magnitude of mental bandwidth.\nSo much more, I could almost imagine myself letting the misunderstanding go while speaking because it would just be so much work to return and correct the record with linear conversation.\n\nWhen writing, the nonlinear edits are possible and easy.\nThe ideas exist concretely in words, to be sculpted into ideas."},{"type":"log","id":"2025/11/21","title":"2025-11-21","description":"","tags":[],"date":"2025-11-21","url":"/logs/2025/11/21","content":"import { Tweet } from 'astro-embed';\n\nI've been thinking about how, in software engineering especially, it feels like the balance of who is the builder and who is the user is shifting.\nIt used to be the case that the software engineer was clearly the builder.\nI don't find that to be the case anymore.\n\nBeing the builder is fun.\nYou get to try new things, experiment, and see your work come to life.\nYou have a lot of control over the process of how you work.\n\nBeing the user, especially of a rapidly changing product, is not always fun.\nAs a user, you adopted a product initially because of its utility, but then the changes start.\n\nPricing changes.\nFeatures evolve or go away.\nThe builders try and increase the scope of their user base.\n\nThe tools used for software engineering are changing.\nLanguage models are in everything, for better or worse.\n\nAs software engineers, we're now experiencing what many of us have put our users through for years.\nBut it's not being done by any one company, but by our industry itself to us.\n\nMore than I can ever recall, organizations seem to be measuring statistics like\n\n- lines of code written\n- PRs merged\n- issues closed\n- daily active sessions on internal tools\n- (and now) inference tokens used\n\nEngineers are now the targets of the optimization loops, previously mostly reserved for the users of the products engineers built.\n\nProdded with surveys\n\n> On a scale of 1 to 10, how likely would you be to recommend this product to a friend or colleague?\n\nTurned upside down and shaken for a bit of knowledge to feed into the tool makers' road maps.\n\nI get it.\nLanguage models change the game for builder software.\n\nI feel this way.\n\nThe tools are useful.\nThe demand for them is real.\n\nBut this post from Lenny has stuck with me:\n\n\n\nFrantically.\n\nOrganizations are pulling out all the usual tools to try and make things happen.\nAnd engineers are feeling the pressure."},{"type":"log","id":"2025/11/15","title":"2025-11-15","description":"","tags":["composer-1"],"date":"2025-11-15","url":"/logs/2025/11/15","content":"Spent several hours coding with Cursor's `composer-1` model.\nI like it a lot and it is so fast.\nWhen you have it working it's one of my favorite agent coding tools I've used.\nWell done."},{"type":"log","id":"2025/11/14","title":"2025-11-14","description":"","tags":["claude-code","rpi"],"date":"2025-11-14","url":"/logs/2025/11/14","content":"I've fallen behind on blog things.\nIn the past few weeks, I've been\n\n- experimenting with [`claude-agent-sdk`](https://github.com/anthropics/claude-agent-sdk-python), equipping the agent with MCP and prompting to use a CLI measure trade-offs and ergonomics\n- using humanlayer's RPI (research, plan, implement) [commands](https://github.com/humanlayer/humanlayer/blob/main/.claude/commands/research_codebase.md) on large codebases to implement complex features\n- experimenting with sprites and tile sets for a game idea"},{"type":"log","id":"2025/11/08","title":"2025-11-08","description":"","tags":["claude-code"],"date":"2025-11-08","url":"/logs/2025/11/08","content":"I built a Claude Code slash command that given a prompt, analyzes the ongoing chat and captures to insight or learning from the conversations.\nThis seems like it's going to be useful for capturing and searching a domain-specific knowledge base using queries that come to mind when I remember I did \"that one thing a few months ago\".\n\nI'm planning to start this as a personal experiment but also see if I can incorporate it codebases with Claude Code commands and agents."},{"type":"log","id":"2025/11/03","title":"2025-11-03","description":"","tags":["toon","dspy"],"date":"2025-11-03","url":"/logs/2025/11/03","content":"I learned about the [TOON](https://github.com/toon-format/toon) input data format for language models.\nI wonder if this could be useful at all for the prompt built by DSPy."},{"type":"log","id":"2025/11/02","title":"2025-11-02","description":"","tags":["rust","claude-code"],"date":"2025-11-02","url":"/logs/2025/11/02","content":"I've been experimenting using Claude Code to learn Rust.\n\nLike learning to write it myself, not just build stuff in it with Claude Code.\nI'm still unsure what level of abstraction learning programming is at now.\n\nI've found, if you're familiar with building software, you can often be pretty serviceable in a language you don't know aided by an agent.\nBut different languages help you learn to think differently about the types of problems you encounter when building software.\n\nI also want to know if and how I can use Claude Code explicitly for the purposes of learning something new.\n\nMy general structure was to prompt the goal of learning Rust, then ask for a plan that covers increasingly advanced topics in Rust.\nThen, given this plan and \"unit\" structure, I prompted for koan-like exercises and a small project for each unit.\n\nClaude Code really wanted to do all the work for me, but with some nudging, I've been able to get it to create the scaffolding for me to learn and then practice.\nAfter making these improvements, I had the agent re-write the plan to incorporate the new approaches."},{"type":"log","id":"2025/10/29","title":"2025-10-29","description":"","tags":["cursor","composer"],"date":"2025-10-29","url":"/logs/2025/10/29","content":"Cursor [released](https://cursor.com/blog/composer) their \"Composer\" model today.\nI believe the name is a hat tip to the original name of their agent/multi-file editing mode.\n\nPer the post\n\n> Composer is a mixture-of-experts (MoE) language model supporting long-context generation and understanding. It is specialized for software engineering through reinforcement learning (RL) in a diverse range of development environments.\n\nI've long been of the opinion that the only way Cursor was going to have staying power as a company was to train their own model.\nIf they hadn't, my thesis was that they would continue to give all their margin away to the lab(s) with the best coding model(s).\n\nCursor has a ton of code data.\nThey also see users' preferences for models.\n\nBy training their own model, maybe they can better control their own destiny and not be at the mercy of the labs and their API pricing.\nThe open question is whether this model is good enough to convince their customers to switch to it."},{"type":"log","id":"2025/10/25","title":"2025-10-25","description":"","tags":[],"date":"2025-10-25","url":"/logs/2025/10/25","content":"I played around with the idea of using a language model as a sort of generic response engine for any request using any protocol.\nThat plan was to write a system prompt that the language model would use as the primary context and role.\nI could then prompt \"you are an HTTP server, you define the following endpoints\" and then send actual HTTP requests to the model and have the model respond as if it were an HTTP server.\nThis idea taken further could allow you to just point a Postgres client or a gRPC client at a port for a process running that wraps a language model and then have it respond based on any kind of definition you did in the system prompt and by its own inference to come up with reasonable responses given the request.\n\nI still feel like there's something to this idea, though early attempts were a little bit rough.\nOne of the bigger challenges is that most language models are pretty slow relative to these deterministic processes.\nAlso, expecting a model to output certain details of a response, like `Content-Length` in an HTTP response, is not reliable.\nTo make parts like that work, you need to add deterministic logic around the model's output.\nIf you do that, it almost makes more sense to just use an agent to scaffold a test service from your specs or IDLs rather than attempt to generate the response with the model via runtime inference."},{"type":"log","id":"2025/10/24","title":"2025-10-24","description":"","tags":["amazon_bedrock","claude","anthropic"],"date":"2025-10-24","url":"/logs/2025/10/24","content":"I've now run into the following issue multiple times using Bedrock.\nIt's my own mistake but I end up confused each time.\n\n```text\nAn error occurred (ValidationException) when calling the InvokeModelWithResponseStream operation:\nThe maximum tokens you requested exceeds the model limit of 65536\n```\n\nI had this prompt when attempting to run inference on Bedrock with `us.anthropic.claude-sonnet-4-20250514-v1:0`.\n\nThe problem was I was trying to set the _output_ tokens larger than the model limit.\nClaude Sonnet 4 has versions that support 200k and 1M tokens context windows but this is for the input tokens to the model.\n\nI hope this note helps if you run into the same issue."},{"type":"log","id":"2025/10/22","title":"2025-10-22","description":"","tags":[],"date":"2025-10-22","url":"/logs/2025/10/22","content":"I've been finding that pairing with someone to help them get familiar with building with agents to be a very effective way to help them get started successfully.\nEveryone enters the process with a different set of skills and it's tough to know what parts will be confusing or challenging for them.\n\nWhen you're pairing, you get to fly through the parts that your pair knows already and stop and focus on the parts that don't come as easily or that they aren't familiar with.\nWith support on the surrounding tasks, they have a chance to get a feel for prompting and developing a workflow for safely trying things out with the ability to revert if something breaks.\n\nWith an agent, you get to bring your expertise to the software you're building.\nThe words, terminology, and your ability to describe what you want are the springboard to using the agent to build what you want.\nBut there are a lot of barriers to entry: the terminal and system setup, getting API keys or paying for an agent subscription, and countless decisions that may feel consequential or irreversible when you don't know better.\nHaving someone trusted to guide you through these parts gives you a great chance to see the opportunity and possibilities of coding with an agent."},{"type":"log","id":"2025/10/20","title":"2025-10-20","description":"","tags":["claude-code","planning"],"date":"2025-10-20","url":"/logs/2025/10/20","content":"I tried out Claude Code's new planning mode recently and ran a demo with it at work today.\nI stumbled upon it last week.\n\nYou get to planning mode by running `claude` and pressing shift+tab twice.\nYou'll see\n\n```text\n ⏸ plan mode on (shift+tab to cycle)\n```\n\nNow, when I am in plan mode, Claude Code takes a sort of Socratic approach, asking me questions to clarify my initial vague prompt\n\n```text\n> let's write a journal cli app\n\n⏺ I'll help you design a journal CLI app! Let me first understand your requirements and then create a comprehensive plan.\n\n\n────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n← ☐ Language ☐ Features ☐ Storage ☐ UI Style ✔ Submit →\n\nWhat programming language would you prefer for the journal CLI app?\n❯ 1. Python\n Great for CLI apps with libraries like Click or argparse. Easy to distribute and cross-platform.\n 2. Node.js/TypeScript\n Modern JavaScript/TypeScript with libraries like Commander.js. Good npm ecosystem.\n 3. Go\n Compiled binary, fast startup, excellent for CLI tools. Built-in flag parsing.\n 4. Rust\n Fast, memory-safe, excellent CLI libraries like clap. Single binary distribution.\n 5. Type something.\n\nEnter to select · Tab/Arrow keys to navigate · Esc to cancel\n```\n\nAn understandable, but sort of weird thing that got me twice today, is if you cursor down to the `Type something.` option and press the arrow keys or tab, the TUI does _not_ cycle to the next plan option like it would if you had one of the other options selected.\nThis kind of makes sense because it's listening for your custom input but I've already gotten stuck on that twice.\n\nSometimes the agent won't ask you any clarifying questions.\nSometimes it will ask multiple rounds of clarifying questions.\n\nI generally like this approach because it's a nice on ramp to the idea of planning and an introduction to the concept that you get better results by giving the agent more of an idea of what you want to build.\nIt reminds me a bit of the work I did on [write-partner](https://github.com/danielcorin/write-partner) 2 years (!) ago, using the model to coax information out of me by asking follow up questions.\n\nIf you expect the agent to read your mind and fill in the gaps, you'll usually be disappointed."},{"type":"log","id":"2025/10/17","title":"2025-10-17","description":"","tags":[],"date":"2025-10-17","url":"/logs/2025/10/17","content":"Shipped the escape room today.\nJust needed to fix a few small bugs with image imports and display.\nThe code is not great but it generally works.\nSaw an interesting performance issue with one of the mini-games on the live site compared to local."},{"type":"til","id":"sqlite/embeddings-with-sqlite-vector","title":"Embeddings with sqlite-vector","description":"","tags":["sqlite","sqlite-vector","embeddings"],"category":"sqlite","date":"2025-10-16T00:45:52.000Z","url":"/til/sqlite/embeddings-with-sqlite-vector","content":"About a year and a half ago I [wrote about using `sqlite-vss`](/til/sqlite/sqlite-vss) to store and query embedding vectors in a SQLite database.\nMuch has changed since then and I'm working on a project that motivated another pass at querying embeddings on a local system for smallish datasets.\nThe [`sqlite-vector`](https://github.com/sqliteai/sqlite-vector) project seemed like an interesting one to try for this purpose.\n\nI am going to use the same [news dataset](https://www.kaggle.com/datasets/rmisra/news-category-dataset) as last time and the [`nomic-embed-text-v1.5`](https://huggingface.co/nomic-ai/nomic-embed-text-v1.5) model to generate 768-dimensional embeddings.\n\nI also downloaded the `vector.dylib` file from the [`sqlite-vector` GitHub repo](https://github.com/sqliteai/sqlite-vector/releases/tag/0.9.37) and placed it in my working directory for this example.\nI've tried exercises similar to this one with both the macOS and Linux versions of the library.\n\nTo get started, we'll install the libraries we will need to load the data, create the database and generate embeddings.\n\n```python\npip install -q pandas scikit-learn sentence-transformers\n```\n\nNext, we'll create the database and table and load the sqlite-vector extension, verifying that it loaded correctly.\n\n```python\nimport sqlite3\nimport json\nfrom pathlib import Path\n\n\nconn = sqlite3.connect('news.db')\nconn.enable_load_extension(True)\nconn.load_extension('./vector.dylib')\nconn.enable_load_extension(False)\n\nversion = conn.execute(\"SELECT vector_version()\").fetchone()[0]\nprint(f\"SQLite Vector extension version: {version}\")\n```\n\n SQLite Vector extension version: 0.9.37\n\nLooks good!\nThe query shows the same [version](https://github.com/sqliteai/sqlite-vector/releases/tag/0.9.37) I downloaded.\n\nIf you haven't taken a look at the dataset yet, here's a sample:\n\n```python\nimport pandas as pd\n\n# Load the first few records to see the structure\ndata_path = Path('data/News_Category_Dataset_v3.json')\narticles = []\n\nwith open(data_path, 'r') as f:\n for i, line in enumerate(f):\n articles.append(json.loads(line))\n\ndf = pd.DataFrame(articles)\ndf.head()\n\n```\n\n| | link | headline | category | short_description | authors | date |\n| --- | ------------------------------------------------- | ------------------------------------------------- | --------- | ------------------------------------------------- | -------------------- | ---------- |\n| 0 | https://www.huffpost.com/entry/covid-boosters-... | Over 4 Million Americans Roll Up Sleeves For O... | U.S. NEWS | Health experts said it is too early to predict... | Carla K. Johnson, AP | 2022-09-23 |\n| 1 | https://www.huffpost.com/entry/american-airlin... | American Airlines Flyer Charged, Banned For Li... | U.S. NEWS | He was subdued by passengers and crew when he ... | Mary Papenfuss | 2022-09-23 |\n| 2 | https://www.huffpost.com/entry/funniest-tweets... | 23 Of The Funniest Tweets About Cats And Dogs ... | COMEDY | \"Until you have a dog you don't understand wha... | Elyse Wanshel | 2022-09-23 |\n| 3 | https://www.huffpost.com/entry/funniest-parent... | The Funniest Tweets From Parents This Week (Se... | PARENTING | \"Accidentally put grown-up toothpaste on my to... | Caroline Bologna | 2022-09-23 |\n| 4 | https://www.huffpost.com/entry/amy-cooper-lose... | Woman Who Called Cops On Black Bird-Watcher Lo... | U.S. NEWS | Amy Cooper accused investment firm Franklin Te... | Nina Golgowski | 2022-09-22 |\n\nFrom here, we'll use the same database connection to create a table to store the news dataset as well as embeddings for both the `short_description` and `headline` fields of the dataset.\n\nI'm only using the first 1000 entries because it takes a few minutes to compute all the embeddings.\n\n```python\nconn.execute(\"\"\"\n CREATE TABLE news_articles (\n id INTEGER PRIMARY KEY AUTOINCREMENT,\n link TEXT,\n headline TEXT,\n category TEXT,\n short_description TEXT,\n authors TEXT,\n date TEXT,\n headline_embedding BLOB,\n description_embedding BLOB\n )\n\"\"\")\n```\n\n```python\nfor _, article in df.head(1000).iterrows():\n conn.execute(\"\"\"\n INSERT INTO news_articles (link, headline, category, short_description, authors, date)\n VALUES (?, ?, ?, ?, ?, ?)\n \"\"\", (\n article['link'],\n article['headline'],\n article['category'],\n article['short_description'],\n article['authors'],\n article['date']\n ))\n\nconn.commit()\n\n\ncount = conn.execute(\"SELECT COUNT(*) FROM news_articles\").fetchone()[0]\nprint(f\"Loaded {count:,} articles\")\n\nprint(\"\\nSample articles:\")\nfor row in conn.execute(\"SELECT id, headline, category FROM news_articles LIMIT 5\"):\n print(f\" [{row[2]}] {row[1][:70]}...\")\n```\n\n Loaded 1,000 articles\n\n Sample articles:\n [U.S. NEWS] Over 4 Million Americans Roll Up Sleeves For Omicron-Targeted COVID Bo...\n [U.S. NEWS] American Airlines Flyer Charged, Banned For Life After Punching Flight...\n [COMEDY] 23 Of The Funniest Tweets About Cats And Dogs This Week (Sept. 17-23)...\n [PARENTING] The Funniest Tweets From Parents This Week (Sept. 17-23)...\n [U.S. NEWS] Woman Who Called Cops On Black Bird-Watcher Loses Lawsuit Against Ex-E...\n\nWith the source data loaded, we'll now generate the embeddings for the `headline` and `short_description` fields, using the `nomic-embed-text-v1.5` model and store those in the database as well.\n\n```python\nfrom sentence_transformers import SentenceTransformer\n\nmodel = SentenceTransformer('nomic-ai/nomic-embed-text-v1.5', trust_remote_code=True)\nprint(f\"Model loaded (embedding dimension: {model.get_sentence_embedding_dimension()})\")\n\n```\n\n Model loaded (embedding dimension: 768)\n\n```python\narticles = conn.execute(\"\"\"\n SELECT id, headline, short_description\n FROM news_articles\n\"\"\").fetchall()\n\nbatch_size = 32\nfor i in range(0, len(articles), batch_size):\n batch = articles[i:i + batch_size]\n article_ids = [article[0] for article in batch]\n headlines = [article[1] for article in batch]\n descriptions = [article[2] if article[2] else \"\" for article in batch]\n\n headline_embeddings = model.encode(headlines, normalize_embeddings=True)\n description_embeddings = model.encode(descriptions, normalize_embeddings=True)\n\n # Store in database as BLOB\n for article_id, h_emb, d_emb in zip(article_ids, headline_embeddings, description_embeddings):\n h_blob = h_emb.tobytes()\n d_blob = d_emb.tobytes()\n conn.execute(\n \"UPDATE news_articles SET headline_embedding = ?, description_embedding = ? WHERE id = ?\",\n (h_blob, d_blob, article_id)\n )\n\n # Commit and show progress every 4000 articles (helpful if you actually load all the data)\n if (i + batch_size) % 4000 == 0 or (i + batch_size) >= len(articles):\n conn.commit()\n print(f\"Processed {min(i + batch_size, len(articles)):,}/{len(articles):,} articles\")\n```\n\n Processed 1,000/1,000 articles\n\nWith the embeddings generated and inserted into the database, we'll now initialize the vector search for both the `headline` and `short_description` fields.\nAccording to the [documentation](https://github.com/sqliteai/sqlite-vector/blob/main/API.md)\n\n> Only tables explicitly initialized using vector_init are eligible for vector search.\n\nSo let's do that:\n\n```python\nconn.execute(\"\"\"\n SELECT vector_init(\n 'news_articles',\n 'headline_embedding',\n 'type=FLOAT32,dimension=768,distance=COSINE'\n )\n\"\"\")\n\nconn.execute(\"\"\"\n SELECT vector_init(\n 'news_articles',\n 'description_embedding',\n 'type=FLOAT32,dimension=768,distance=COSINE'\n )\n\"\"\")\n```\n\nWe could also [quantize](https://github.com/sqliteai/sqlite-vector/blob/main/QUANTIZATION.md) the vector for faster and more efficient search, but let's save that for another time.\n\nWith our embeddings generated and initialized, we can now define the search functions over the two fields.\nBefore we do though, we'll briefly discuss how the search functions work.\nWe start by taking `query_text` and encoding it using the same model we used to generate the embeddings.\n\n```python\nencoded = model.encode([\"hello world!\"])[0]\nencoded[:20] # truncated for brevity\n```\n\n array([ 0.12390442, -0.06160246, -3.9840953 , -0.24632797, -0.3041943 ,\n 1.5918531 , -0.20516105, -0.6006584 , -0.22573042, -1.319676 ,\n 0.31299376, 1.2585417 , 0.49875298, 1.381727 , 0.5602437 ,\n -1.0751574 , 0.27402204, -1.1879947 , -0.98643625, 0.46151334],\n dtype=float32)\n\nSpecifically, the size of the vector is equal to the number of dimensions of the embedding model.\n\n```python\nencoded.shape\n```\n\n (768,)\n\nGiven this approach, let's show how we can calculate the distance of a `query` from one of the `headline`s in the dataset.\nAs we specified in `vector_init`, we will use cosine distance (`distance=COSINE`).\n\n```python\nfrom sklearn.metrics.pairwise import cosine_similarity\n\n\nquery = \"sports\"\nheadline = \"New York City To Let Unvaccinated Athletes Play Home Games\"\n\nquery_embedding = model.encode([query], normalize_embeddings=True)\nheadline_embedding = model.encode([headline], normalize_embeddings=True)\n\nsimilarity = cosine_similarity(query_embedding, headline_embedding)\nprint(1-similarity)\n\n```\n\n [[0.34292662]]\n\nBack to analyzing our dataset -- since I normalized the embeddings when I encoded them above, we'll also need to do that here.\nFinally, we'll get the output as an array that we can convert to a blob (our column data type of the embeddings) and pass it to the `vector_full_scan` function.\n\n```python\nf\"{model.encode([\"hello world!\"], normalize_embeddings=True).tobytes()[:20]}...\"\n```\n\n \"b'\\\\r-\\\\xb4;\\\\xa8(3\\\\xbb\\\\xdf\\\\x0b5\\\\xbej\\\\x193\\\\xbc*,]\\\\xbc'...\"\n\n```python\ndef search_by_headline(conn, query_text, top_k=5):\n query_embedding = model.encode([query_text], normalize_embeddings=True)\n query_blob = query_embedding.tobytes()\n\n results = conn.execute(\"\"\"\n SELECT a.id, a.headline, a.category, a.short_description, v.distance\n FROM news_articles AS a\n JOIN vector_full_scan('news_articles', 'headline_embedding', ?, ?) AS v\n ON a.id = v.rowid\n ORDER BY v.distance ASC\n \"\"\", (query_blob, top_k)).fetchall()\n\n return results\n\n\ndef search_by_description(conn, query_text, top_k=5):\n query_embedding = model.encode([query_text], normalize_embeddings=True)\n query_blob = query_embedding.tobytes()\n\n results = conn.execute(\"\"\"\n SELECT a.id, a.headline, a.category, a.short_description, v.distance\n FROM news_articles AS a\n JOIN vector_full_scan('news_articles', 'description_embedding', ?, ?) AS v\n ON a.id = v.rowid\n ORDER BY v.distance ASC\n \"\"\", (query_blob, top_k)).fetchall()\n\n return results\n```\n\nLet's run some semantic queries and see what we find!\nThis should look familiar -- we're using the same query we embedded and calculated cosine distance for above.\n\n```python\nquery = \"sports\"\n\nheadline_results = search_by_headline(conn, query, top_k=3)\nfor i, (article_id, headline, category, description, distance) in enumerate(headline_results, 1):\n print(f\"{i}. [{category}] {headline} (distance: {distance:.4f})\")\n```\n\n 1. [U.S. NEWS] New York City To Let Unvaccinated Athletes Play Home Games (distance: 0.3429)\n 2. [SPORTS] Video Shows NFL Player Hopping Into Stands To Stop Fighting Fans (distance: 0.3828)\n 3. [POLITICS] NBA Won't Host Election Day Games In Effort To Increase Voter Turnout (distance: 0.4232)\n\nWe see an identical result as we calculated above for the first (and closest) headline match `(distance: 0.3429)`.\n\nNow we can run a similar query on the `description` field:\n\n```python\ndescription_results = search_by_description(conn, query, top_k=3)\nfor i, (article_id, headline, category, description, distance) in enumerate(description_results, 1):\n print(f\"{i}. [{category}] {headline} (distance: {distance:.4f})\")\n print(f\" Description: {description}\")\n```\n\n 1. [SPORTS] Las Vegas Aces Win First WNBA Title, Chelsea Gray Named MVP (distance: 0.3580)\n Description: Las Vegas never had a professional sports champion — until Sunday.\n 2. [SPORTS] Lucius Fox Makes Sickening Exit Just 2 Pitches Into Game (distance: 0.3966)\n Description: The Washington Nationals infielder became a hurler for one gross moment — which was caught on video — against the San Francisco Giants.\n 3. [SPORTS] Diego Maradona's 'Hand Of God' Jersey Sells For Record Sum (distance: 0.4160)\n Description: The Argentine soccer superstar wore the shirt when he scored the controversial goal against England in the 1986 World Cup.\n\n```python\nheadline_results = search_by_headline(conn, \"artificial intelligence\", top_k=3)\ndescription_results = search_by_description(conn, \"artificial intelligence\", top_k=3)\n\nfor i, (article_id, headline, category, description, distance) in enumerate(headline_results, 1):\n print(f\"{i}. [{category}] {headline} (distance: {distance:.4f})\")\n\nprint()\n\nfor i, (article_id, headline, category, description, distance) in enumerate(description_results, 1):\n print(f\"{i}. [{category}] {description} (distance: {distance:.4f})\")\n```\n\n 1. [TECH] Google Engineer On Leave After He Claims AI Program Has Gone Sentient (distance: 0.3774)\n 2. [CULTURE & ARTS] How Ani Liu Is Brilliantly Disguising Her Art As Science (distance: 0.5151)\n 3. [ENTERTAINMENT] Andrew Garfield Confirms Method Acting Is Possible Without 'Being An Asshole' (distance: 0.5217)\n\n 1. [TECH] Artificially intelligent chatbot generator LaMDA wants “to be acknowledged as an employee of Google rather than as property,\" says engineer Blake Lemoine. (distance: 0.4230)\n 2. [POLITICS] The House Intelligence Committee hearing follows a 2021 report of a possible national security \"challenge\" from UFOs. (distance: 0.4950)\n 3. [U.S. NEWS] The American Academy of Pediatrics says it is putting all its guidance under the microscope to eliminate “race-based” medicine and resulting health disparities. (distance: 0.4967)\n\nEmbeddings and cosine distance allow us to do search over the `headline` and `short_description` fields of the dataset, finding semantically similar results even if the results themselves don't contain or match the query text or parts of the query text exactly."},{"type":"log","id":"2025/10/13","title":"2025-10-13","description":"","tags":["sqlite","datasette","sqlite-vector"],"date":"2025-10-13","url":"/logs/2025/10/13","content":"Experimenting with the useful [sqlite-vector](https://github.com/sqliteai/sqlite-vector) library for managing vector embeddings in SQLite.\nAlso wrote up a [Datasette plugin](https://docs.datasette.io/en/stable/writing_plugins.html) to query the embeddings in the [Datasette tool](https://docs.datasette.io/en/stable/).\n\nThis seems to be faster and easier than I last attempted this a year and a half ago with [sqlite-vss](/til/sqlite/sqlite-vss)."},{"type":"til","id":"dspy/debugging","title":"Debugging DSPy token usage and prompts","description":"","tags":["dspy"],"category":"dspy","date":"2025-10-12T19:37:35.000Z","url":"/til/dspy/debugging","content":"As I've experimented more with DSPy, I've attempted to dig further into the details of the specific LLM I am using to better understand things like token usage, reasoning, and the specific prompts being sent to the model.\nWhile, DSPy's abstraction is one of the more lightweight for LLM frameworks, in my experience, I generally want to see what is being sent to the model when I'm trying to debug or improve performance for a use case.\n\n## A simple example\n\nWe will start with a classic example for me -- using DSPy to extract a date from a sentence in a specific format.\n\n```python\nimport dspy\n```\n\n```python\nclass ExtractDate(dspy.Signature):\n \"\"\"Extract a date in yyyy-mm-dd format from the given sentence.\"\"\"\n\n sentence = dspy.InputField(desc=\"The input sentence containing a date\")\n date = dspy.OutputField(desc=\"The extracted date in yyyy-mm-dd format\")\n```\n\n```python\nsentence = \"The meeting is scheduled for March 15th, 2024.\"\n```\n\nThe first question I often find myself asking is \"how many tokens did that inference use?\"\nThis is exposed in a straightforward way with DSPy but the framework also enables `cache` by default.\nWhen experimenting, this is a great help because the framework avoids re-running inference it has already run before, saving you time and money.\nHowever, when trying to measure token utilization (which you'll usually attempt after already running an inference at least once), this caching prevents you from seeing the actual token usage because in practice, for that call, there wasn't any.\nThe result was pulled from cache.\n\nTo consistently see the token usage, the most straightforward approach I have found is to disable caching.\n\n```python\nextract_date = dspy.Predict(ExtractDate)\n\n\nwith dspy.settings.context(lm=dspy.LM(\"openai/gpt-4.1-mini\", cache=False), track_usage=True):\n result = extract_date(sentence=sentence)\n print(result)\n\n usage = result.get_lm_usage()\n print(usage)\n\n```\n\n Prediction(\n date='2024-03-15'\n )\n {'openai/gpt-4.1-mini': {'completion_tokens': 17, 'prompt_tokens': 167, 'total_tokens': 184, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0, 'text_tokens': None}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0, 'text_tokens': None, 'image_tokens': None}}}\n\nLet's make a function to report the results and usage, since we're going to do this a lot.\n\n```python\nimport json\n\n\ndef filter_none_recursive(obj):\n if isinstance(obj, dict):\n return {k: filter_none_recursive(v) for k, v in obj.items() if v is not None}\n elif isinstance(obj, list):\n return [filter_none_recursive(item) for item in obj if item is not None]\n else:\n return obj\n\ndef print_results_and_usage(result):\n usage = result.get_lm_usage()\n print(result)\n filtered_usage = filter_none_recursive(usage)\n print(json.dumps(filtered_usage, indent=2))\n```\n\nNow we can take a look at the different ways to configure the model with DSPy to output its response using reasoning.\n\nGemini Flash 2.5 uses reasoning by default.\n\n```python\nwith dspy.settings.context(lm=dspy.LM(\"gemini/gemini-2.5-flash\", cache=False), track_usage=True):\n result = extract_date(sentence=sentence)\n print_results_and_usage(result)\n```\n\n Prediction(\n date='2024-03-15'\n )\n {\n \"gemini/gemini-2.5-flash\": {\n \"completion_tokens\": 133,\n \"prompt_tokens\": 179,\n \"total_tokens\": 312,\n \"completion_tokens_details\": {\n \"reasoning_tokens\": 111,\n \"text_tokens\": 22\n },\n \"prompt_tokens_details\": {\n \"text_tokens\": 179\n }\n }\n }\n\nThis can be disabled by setting `reasoning_effort` to `disable` on `dspy.LM`.\n\n```python\nwith dspy.settings.context(\n lm=dspy.LM(\"gemini/gemini-2.5-flash\", cache=False, reasoning_effort=\"disable\"),\n track_usage=True,\n):\n result = extract_date(sentence=sentence)\n print_results_and_usage(result)\n```\n\n Prediction(\n date='2024-03-15'\n )\n {\n \"gemini/gemini-2.5-flash\": {\n \"completion_tokens\": 22,\n \"prompt_tokens\": 179,\n \"total_tokens\": 201,\n \"prompt_tokens_details\": {\n \"text_tokens\": 179\n }\n }\n }\n\nIt can also be disabled by setting `reasoning_effort` to `disable` on the `Predict` instance.\n\n```python\nwith dspy.settings.context(\n lm=dspy.LM(\"gemini/gemini-2.5-flash\", cache=False),\n track_usage=True,\n):\n result = extract_date(\n sentence=sentence,\n config={\"reasoning_effort\": \"disable\"},\n )\n print_results_and_usage(result)\n```\n\n Prediction(\n date='2024-03-15'\n )\n {\n \"gemini/gemini-2.5-flash\": {\n \"completion_tokens\": 22,\n \"prompt_tokens\": 179,\n \"total_tokens\": 201,\n \"prompt_tokens_details\": {\n \"text_tokens\": 179\n }\n }\n }\n\nFollowing the first approach, we can set `reasoning_effort` to `high` to attempt to elicit more reasoning tokens from the model.\n\n```python\nwith dspy.settings.context(\n lm=dspy.LM(\"gemini/gemini-2.5-flash\", cache=False, reasoning_effort=\"high\"),\n track_usage=True,\n):\n result = extract_date(sentence=sentence)\n print_results_and_usage(result)\n```\n\n Prediction(\n date='2024-03-15'\n )\n {\n \"gemini/gemini-2.5-flash\": {\n \"completion_tokens\": 153,\n \"prompt_tokens\": 179,\n \"total_tokens\": 332,\n \"completion_tokens_details\": {\n \"reasoning_tokens\": 131,\n \"text_tokens\": 22\n },\n \"prompt_tokens_details\": {\n \"text_tokens\": 179\n }\n }\n }\n\nWe can do something similar with GPT-5, OpenAI's hybrid reasoning model.\nNote: The OpenAI API requires `temperature=1` and `max_tokens >= 16000` for the `gpt-5` model, hence the changes below.\n\n```python\nwith dspy.settings.context(\n lm=dspy.LM(\"openai/gpt-5\", temperature=1, max_tokens=16000, cache=False, reasoning_effort=\"low\"),\n track_usage=True,\n):\n result = extract_date(sentence=sentence)\n print_results_and_usage(result)\n```\n\n Prediction(\n date='2024-03-15'\n )\n {\n \"openai/gpt-5\": {\n \"completion_tokens\": 90,\n \"prompt_tokens\": 166,\n \"total_tokens\": 256,\n \"completion_tokens_details\": {\n \"accepted_prediction_tokens\": 0,\n \"audio_tokens\": 0,\n \"reasoning_tokens\": 64,\n \"rejected_prediction_tokens\": 0\n },\n \"prompt_tokens_details\": {\n \"audio_tokens\": 0,\n \"cached_tokens\": 0\n }\n }\n }\n\nBut it doesn't work in exactly the same way as Gemini.\nHere we see a LiteLLM error (the underlying translation layer DSPy uses to support different LLM providers), where our `reasoning_effort` configuration is invalid for the OpenAI API.\n\n```python\nwith dspy.settings.context(\n lm=dspy.LM(\"openai/gpt-5\", temperature=1, max_tokens=16000, cache=False, reasoning_effort=\"disable\"),\n track_usage=True,\n):\n result = extract_date(sentence=sentence)\n```\n\n```text wrap=true\n...\nBadRequestError: litellm.BadRequestError: OpenAIException - Invalid value: 'disable'. Supported values are: 'low', 'medium', and 'high'.\n```\n\n## Inspecting raw prompts and responses with history\n\nWe've experimented with configuring a few different LLMs.\nNow, let's inspect the output of their inference and the prompts DSPy sends to the model.\nEach LM instance maintains a `history` list that contains detailed information about every call, including the raw messages, responses, and usage stats.\n\nLet's take a look at this.\n\n```python\nlm = dspy.LM(\"openai/gpt-5-mini\", cache=False, temperature=1, max_tokens=16000)\n\nwith dspy.settings.context(lm=lm, track_usage=True):\n result = extract_date(sentence=sentence, config={\"reasoning_effort\": \"high\"})\n\n```\n\n```python\nlm.history\n```\n\n [{'prompt': None,\n 'messages': [{'role': 'system',\n 'content': 'Your input fields are:\\n1. `sentence` (str): The input sentence containing a date\\nYour output fields are:\\n1. `date` (str): The extracted date in yyyy-mm-dd format\\nAll interactions will be structured in the following way, with the appropriate values filled in.\\n\\n[[ ## sentence ## ]]\\n{sentence}\\n\\n[[ ## date ## ]]\\n{date}\\n\\n[[ ## completed ## ]]\\nIn adhering to this structure, your objective is: \\n Extract a date in yyyy-mm-dd format from the given sentence.'},\n {'role': 'user',\n 'content': '[[ ## sentence ## ]]\\nThe meeting is scheduled for March 15th, 2024.\\n\\nRespond with the corresponding output fields, starting with the field `[[ ## date ## ]]`, and then ending with the marker for `[[ ## completed ## ]]`.'}],\n 'kwargs': {'reasoning_effort': 'high'},\n 'response': ModelResponse(id='chatcmpl-CPw9qDTZzuUNjdNIbFladiHQkXGTe', created=1760297794, model='gpt-5-mini-2025-08-07', object='chat.completion', system_fingerprint=None, choices=[Choices(finish_reason='stop', index=0, message=Message(content='[[ ## date ## ]]\\n2024-03-15\\n\\n[[ ## completed ## ]]', role='assistant', tool_calls=None, function_call=None, provider_specific_fields={'refusal': None}, annotations=[]), provider_specific_fields={})], usage=Usage(completion_tokens=154, prompt_tokens=166, total_tokens=320, completion_tokens_details=CompletionTokensDetailsWrapper(accepted_prediction_tokens=0, audio_tokens=0, reasoning_tokens=128, rejected_prediction_tokens=0, text_tokens=None), prompt_tokens_details=PromptTokensDetailsWrapper(audio_tokens=0, cached_tokens=0, text_tokens=None, image_tokens=None)), service_tier='default'),\n 'outputs': ['[[ ## date ## ]]\\n2024-03-15\\n\\n[[ ## completed ## ]]'],\n 'usage': {'completion_tokens': 154,\n 'prompt_tokens': 166,\n 'total_tokens': 320,\n 'completion_tokens_details': CompletionTokensDetailsWrapper(accepted_prediction_tokens=0, audio_tokens=0, reasoning_tokens=128, rejected_prediction_tokens=0, text_tokens=None),\n 'prompt_tokens_details': PromptTokensDetailsWrapper(audio_tokens=0, cached_tokens=0, text_tokens=None, image_tokens=None)},\n 'cost': 0.0003495,\n 'timestamp': '2025-10-12T15:36:37.579158',\n 'uuid': '2f29dbd0-18d4-4a1b-9791-578221b5c1c7',\n 'model': 'openai/gpt-5-mini',\n 'response_model': 'gpt-5-mini-2025-08-07',\n 'model_type': 'chat'}]\n\n```python\nlm.inspect_history(1)\n```\n\n [2025-10-12T15:36:37.579158]\n\n System message:\n\n Your input fields are:\n 1. `sentence` (str): The input sentence containing a date\n Your output fields are:\n 1. `date` (str): The extracted date in yyyy-mm-dd format\n All interactions will be structured in the following way, with the appropriate values filled in.\n\n [[ ## sentence ## ]]\n {sentence}\n\n [[ ## date ## ]]\n {date}\n\n [[ ## completed ## ]]\n In adhering to this structure, your objective is:\n Extract a date in yyyy-mm-dd format from the given sentence.\n\n\n User message:\n\n [[ ## sentence ## ]]\n The meeting is scheduled for March 15th, 2024.\n\n Respond with the corresponding output fields, starting with the field `[[ ## date ## ]]`, and then ending with the marker for `[[ ## completed ## ]]`.\n\n\n Response:\n\n [[ ## date ## ]]\n 2024-03-15\n\n [[ ## completed ## ]]\n\nHere we see almost everything we'd want to know about the prompt DSPy sent and the response it received from the model.\nWe even see `kwargs` overrides that were passed for the specific call.\n\nThe main thing we miss is the configuration of the LM instance itself for that specific message, which we can get like this:\n\n```python\nlm.dump_state()\n```\n\n {'model': 'openai/gpt-5-mini',\n 'model_type': 'chat',\n 'cache': False,\n 'num_retries': 3,\n 'finetuning_model': None,\n 'launch_kwargs': {},\n 'train_kwargs': {},\n 'temperature': 1,\n 'max_completion_tokens': 16000}\n\nThis isn't necessarily a foolproof way to get what the LM configuration was at call time because the LM and its `kwargs` are mutable.\nIt's possible (though probably not advisable) to change them after the call has been made.\nHowever, for my own experimentation purposes, I've found the above functions to be helpful.\n\nRemember to re-enable caching when you're done inspecting token usage to save time and cost!"},{"type":"log","id":"2025/10/08","title":"2025-10-08","description":"","tags":[],"date":"2025-10-08","url":"/logs/2025/10/08","content":"I started a list of things that seem to come up frequently when it comes to enduring design and user experience and empowerment.\nCurrently the list is the following:\n\n- Spreadsheets\n- Bicycles\n- Legos\n- Unix"},{"type":"log","id":"2025/10/04","title":"2025-10-04","description":"","tags":["claude-code","codex"],"date":"2025-10-04","url":"/logs/2025/10/04","content":"I downgraded Claude Code to standard usage a little while ago and I have to say it's one of the best things I've done recently.\nNot to say that I think Claude Code is excellent and effective - it is - but when I (occasionally) max out my Claude Code quota, I'm motivated to try a different agent coding tool.\n\nToday, I did more work with `codex` than I've attempted in a while and found it to be quite effective and enjoyable."},{"type":"log","id":"2025/10/02","title":"2025-10-02","description":"","tags":["claude-code"],"date":"2025-10-02","url":"/logs/2025/10/02","content":"Currently watching [this video](https://www.youtube.com/watch?v=42AzKZRNhsk) a bit at a time.\n\nLots of great takeaways.\nA memorable one - references specific Claude Code tools by name when prompting."},{"type":"log","id":"2025/10/01","title":"2025-10-01","description":"","tags":["claude-code"],"date":"2025-10-01","url":"/logs/2025/10/01","content":"ctrl + v on macOS pastes and image from the clipboard into\nClaude Code. Amazing to finally know how to do this."},{"type":"log","id":"2025/09/29","title":"2025-09-29","description":"","tags":["claude-code"],"date":"2025-09-29","url":"/logs/2025/09/29","content":"Cute detail from the Claude Code update today\n\n![Multi-colored Claude Code ultrathink styling](images/ultrathink.png)"},{"type":"til","id":"dspy/intro","title":"Intro to DSPy","description":"","tags":["dspy"],"category":"dspy","date":"2025-09-28T18:43:52.208Z","url":"/til/dspy/intro","content":"The viral \"how many r's are there in the word 'strawberry'?\" problem is a great motivating example to experiment with the capabilities of [DSPy](https://github.com/stanfordnlp/dspy), an increasingly popular, powerful library for running inference with language models.\nWhile the counting letters problem itself is a poor application of a language model, using DSPy to experiment helps us build intuition for how to make a language model perform better at a specific task, using manual and language model-based optimization approaches.\n\n```python\nimport dspy\nimport pandas as pd\n\nfrom dspy.evaluate import Evaluate\n```\n\n```python\ngpt_4_1_nano_lm = dspy.LM('openai/gpt-4.1-nano-2025-04-14')\n\n```\n\nA `Signature` is the foundational primitive in DSPy.\nPersonally, I think of a signature (or typed object) as the standard primitive of interacting with any language model in general.\n\nUnless you are building a pure chatbot, to stitch the functionality of the LLM into your application, you're going to need to impose structure on the outputs of the LLM.\n\nImposing structure on the inputs helps too.\nThe better these are labeled, the more likely the output for the model will be aligned with the correct answer you're looking for.\n\nIf you don't buy that, let's see if I can convince you it is true.\n\nA `Signature` is just one part of a functioning LLM application.\nThe next most important primitive of building with a language model is a dataset.\n\nOnce you know your inputs and outputs to the model, you need to figure out if the inference the model is doing is correct, based on your own measurement of what that means.\nWithout doing this, you won't know if your prompt and inputs combination results in inference with the correct output.\n\nThe `Signature` forces you to think about what information is relevant and what the shape of the answer looks like.\nSystematizing and automating inference with this process allows you to experiment with and evolve the signature while guarding against regressions.\n\nWith that context, let's create a DSPy signature to count the number of occurrences of a specific letter in a given word, modelling off the \"how many r's are there in the word 'strawberry'\" example.\n\n```python\nclass CountLetterInWord(dspy.Signature):\n \"\"\"Count the number of occurrences of a specific letter in a given word.\"\"\"\n\n word: str = dspy.InputField(desc=\"The word to search in\")\n letter: str = dspy.InputField(desc=\"The letter to count\")\n count: int = dspy.OutputField(desc=\"The number of times the `letter` appears in the `word`\")\n```\n\n```python\ncount_letter = dspy.Predict(CountLetterInWord)\n```\n\nWith a `Signature` and `Predict` classes defined, we can now map inputs to outputs using the LLM.\n\n```python\nwith dspy.settings.context(lm=gpt_4_1_nano_lm):\n result = count_letter(word='basketball', letter='b')\n\nresult\n```\n\n Prediction(\n count=2\n )\n\nThe model got this one right!\n\nFrom here, let's use the system dictionary (`/usr/share/dict/words`) to create a dataset of words and their letter counts.\nWe'll use this dataset to evaluate the performance of different signatures, models, and eventually optimization approaches.\n\n```python\nimport csv\nimport os\nimport random\n\n# Read words from system dictionary\nwith open('/usr/share/dict/words', 'r') as f:\n words = [word.strip().lower() for word in f.readlines() if word.strip()]\n\n# Sample 400 words randomly\nsample_words = random.sample(words, min(400, len(words)))\n\n# Create dataset\ndataset = []\nfor word in sample_words:\n # Pick a random letter from the word\n letter = random.choice(word)\n # Count occurrences of that letter in the word\n count = word.count(letter)\n dataset.append([word, letter, count])\n\n```\n\nFor a bit more data diversity, let's also add 100 rows where the letter is not in the word.\n\n```python\n# Add 100 rows where the letter is not in the word\nfor _ in range(100):\n word = random.choice(sample_words)\n # Find a letter that's not in the word\n alphabet = 'abcdefghijklmnopqrstuvwxyz'\n available_letters = [letter for letter in alphabet if letter not in word]\n if available_letters:\n letter = random.choice(available_letters)\n dataset.append([word, letter, 0])\n\n# Create the dataset directory if it doesn't exist\nos.makedirs('dataset', exist_ok=True)\n\n# Write the dataset to CSV\nwith open('dataset/word_letter_dataset.csv', 'w', newline='') as csvfile:\n writer = csv.writer(csvfile)\n writer.writerow(['word', 'letter', 'count'])\n writer.writerows(dataset)\n\nprint(f\"Updated dataset with {len(dataset)} rows total\")\n```\n\nNow, let's load the dataset we created and start to experiment\n\n```python\ndf = pd.read_csv('dataset/word_letter_dataset.csv')\ndf.head()\n```\n\n| | word | letter | count |\n| --- | --------- | ------ | ----- |\n| 0 | uniate | t | 1 |\n| 1 | ridiculer | r | 2 |\n| 2 | market | e | 1 |\n| 3 | subsident | n | 1 |\n| 4 | irisation | i | 3 |\n\nUsing DSPy's `Evaluate` class, we can create a list of examples and a simple metric to evaluate the performance of our signature and model against the labeled dataset.\nRemember, given our `CountLetterInWord` signature, the inputs are `word` and `letter` and the output generated using LLM inference is `count`.\nOur dataframe loaded from the csv has all three of these values, so we can use the `Evaluate` class to determine how often our model inference is (based on the `Signature`) actually outputs the correct answer.\n\nLet's try running inference on 50 random examples from the dataset.\n\n```python\nsampled_df = df.sample(n=50, random_state=42)\n\nexamples = []\n\nfor _, row in sampled_df.iterrows():\n examples.append(dspy.Example(\n word=row['word'],\n letter=row['letter'],\n count=row['count']\n ).with_inputs('word', 'letter'))\n\ndef letter_count_metric(example, prediction, trace=None):\n return example.count == prediction.count\n\n\nevaluator = Evaluate(\n devset=examples,\n metric=letter_count_metric,\n num_threads=1,\n)\n```\n\n```python\nwith dspy.settings.context(lm=gpt_4_1_nano_lm):\n results = evaluator(count_letter)\n```\n\n 2025/09/28 17:03:14 INFO dspy.evaluate.evaluate: Average Metric: 36 / 50 (72.0%)\n\nInference from `gpt-4.1-nano-2025-04-14` gets 72% of the examples correct.\nNot bad but room for improvement.\n\nHere's an example of a failure:\n\n```python\nprint('Error for standard inference:\\n')\nfor i, result in enumerate(results.results):\n example, prediction, correct = result\n predicted = prediction.count\n actual = example.count\n word = example.word\n letter = example.letter\n\n if not correct:\n print(result)\n break\n```\n\n Error for standard inference:\n\n (Example({'word': 'thermogeography', 'letter': 'e', 'count': 2}) (input_keys={'word', 'letter'}), Prediction(\n reasoning=\"I need to count how many times the letter 'e' appears in the word 'thermogeography'. I will examine each letter in the word and check if it matches 'e'. The word is 'thermogeography', which contains the following letters: t, h, e, r, m, o, g, r, a, p, h, y. The letter 'e' appears once in the third position. Therefore, the total count of 'e' in the word is 1.\",\n count=1\n ), False)\n\n## Improving accuracy\n\n\"Chain of thought\" or \"reasoning\" has become such a common pattern to improve the performance of language models that DSPy has a built-in class for it.\nThese approaches both effectively mean prompting to get the model to output more tokens moving in the direction of the correct answer.\nDoing this improves the performance of the model.\nIt kind of makes sense.\nIt's kind of surprising.\nGiven how the models are built today, it seems to work in a lot of scenarios.\n\nWe can wrap our signature in the `ChainOfThought` class in DSPy which will elicit a chain of thought from the LLM and capture it in a field called `reasoning` as the first output field.\nIt's important that the field is the first output field as the reasoning leads the model in the direction of the correct answer.\n\n```python\ncount_letter_cot = dspy.ChainOfThought(CountLetterInWord)\n```\n\n```python\nwith dspy.settings.context(lm=gpt_4_1_nano_lm):\n cot_results = evaluator(count_letter_cot)\n```\n\n 2025/09/28 17:48:16 INFO dspy.evaluate.evaluate: Average Metric: 43 / 50 (86.0%)\n\nBetter already!\n\nWe can now look at some of the failures and see the model's reasoning process as well:\n\n```python\nprint('Error results for chain of thought:\\n')\nfor i, result in enumerate(cot_results.results):\n example, prediction, correct = result\n predicted = prediction.count\n actual = example.count\n word = example.word\n letter = example.letter\n\n if not correct:\n print(result)\n break\n```\n\n Error results for chain of thought:\n\n (Example({'word': 'voicelike', 'letter': 'e', 'count': 2}) (input_keys={'word', 'letter'}), Prediction(\n reasoning=\"The task is to count how many times the letter 'e' appears in the word 'voicelike'. I will examine the word and count each occurrence of 'e'. The word 'voicelike' contains the letter 'e' at the end, and it appears once in the word.\",\n count=1\n ), False)\n\nThe reasoning is faulty.\nIn fact it's not really reasoning at all and it's not leading the model to the correct answer.\n\nWhy is this?\nA good first place to look is the prompt that DSPy sent to the model.\nThis pulls back the curtain on the `Signature` abstraction to show us the actual prompting being sent to the model.\n\nWriting DSPy code is still just prompting the LLM, but it's convenient and clever prompting wired into a powerful abstraction.\nBy focusing on the inputs, outputs, and their types and descriptions, DSPy allows you to focus on the most important parts that influence the quality of the inference but still mostly work with code not prompts.\n\n```python\nprint(count_letter_cot.history[-1]['messages'][0]['content']) # system message\nprint(count_letter_cot.history[-1]['messages'][1]['content']) # user message\n```\n\n Your input fields are:\n 1. `word` (str): The word to search in\n 2. `letter` (str): The letter to count\n Your output fields are:\n 1. `reasoning` (str):\n 2. `count` (int): The number of times the `letter` appears in the `word`\n All interactions will be structured in the following way, with the appropriate values filled in.\n\n [[ ## word ## ]]\n {word}\n\n [[ ## letter ## ]]\n {letter}\n\n [[ ## reasoning ## ]]\n {reasoning}\n\n [[ ## count ## ]]\n {count} # note: the value you produce must be a single int value\n\n [[ ## completed ## ]]\n In adhering to this structure, your objective is:\n Count the number of occurrences of a specific letter in a given word.\n [[ ## word ## ]]\n anisosepalous\n\n [[ ## letter ## ]]\n s\n\n Respond with the corresponding output fields, starting with the field `[[ ## reasoning ## ]]`, then `[[ ## count ## ]]` (must be formatted as a valid Python int), and then ending with the marker for `[[ ## completed ## ]]`.\n\nThe prompt structure makes sense but the reasoning the model did to get to the answer did not.\n\nLet's modify the signature to include a step-by-step explanation of how we want to model to reason to figure out the answer for this problem.\n\n```python\nclass CountLetterInWordStrategic(dspy.Signature):\n \"\"\"\n Count the number of occurrences of a specific letter in a given word.\n\n To accomplish this task, for each letter in the word, check if it matches the target letter.\n For example, if we are looking for the letter 'a' in the word 'banana':\n\n 1. b - this is not an 'a'\n 2. a - this is an 'a'\n 3. n - this is not an 'a'\n 4. a - this is an 'a'\n 5. n - this is not an 'a'\n 6. a - this is an 'a'\n\n We count 3 'a's in the word 'banana'\n \"\"\"\n\n reasoning: str = dspy.OutputField(desc=\"A step-by-step explanation of the reasoning process\")\n word: str = dspy.InputField(desc=\"The word to search in\")\n letter: str = dspy.InputField(desc=\"The letter to count\")\n count: int = dspy.OutputField(desc=\"The number of times the `letter` appears in the `word`\")\n```\n\n```python\ncount_letter_strategic = dspy.Predict(CountLetterInWordStrategic)\nwith dspy.settings.context(lm=gpt_4_1_nano_lm):\n results = evaluator(count_letter_strategic)\n```\n\n 2025/09/28 17:49:49 INFO dspy.evaluate.evaluate: Average Metric: 48 / 50 (96.0%)\n\nWay better!\n\nSo what did this addition of the Python docstring do?\nWe can check the prompt and see the difference:\n\n```python\nprint(count_letter_strategic.history[-1]['messages'][0]['content']) # system message\nprint(count_letter_strategic.history[-1]['messages'][1]['content']) # user message\n```\n\n Your input fields are:\n 1. `word` (str): The word to search in\n 2. `letter` (str): The letter to count\n Your output fields are:\n 1. `reasoning` (str): A step-by-step explanation of the reasoning process\n 2. `count` (int): The number of times the `letter` appears in the `word`\n All interactions will be structured in the following way, with the appropriate values filled in.\n\n [[ ## word ## ]]\n {word}\n\n [[ ## letter ## ]]\n {letter}\n\n [[ ## reasoning ## ]]\n {reasoning}\n\n [[ ## count ## ]]\n {count} # note: the value you produce must be a single int value\n\n [[ ## completed ## ]]\n In adhering to this structure, your objective is:\n Count the number of occurrences of a specific letter in a given word.\n\n To accomplish this task, for each letter in the word, check if it matches the target letter.\n For example, if we are looking for the letter 'a' in the word 'banana':\n\n 1. b - this is not an 'a'\n 2. a - this is an 'a'\n 3. n - this is not an 'a'\n 4. a - this is an 'a'\n 5. n - this is not an 'a'\n 6. a - this is an 'a'\n\n We count 3 'a's in the word 'banana'\n [[ ## word ## ]]\n anisosepalous\n\n [[ ## letter ## ]]\n s\n\n Respond with the corresponding output fields, starting with the field `[[ ## reasoning ## ]]`, then `[[ ## count ## ]]` (must be formatted as a valid Python int), and then ending with the marker for `[[ ## completed ## ]]`.\n\nAdding the docstring gets DSPy add the section \"In adhering to this structure, your objective is: ...\" to the prompt.\n\nWe can also inspect the reasoning from one of the inferences to see the difference:\n\n```python\nprint(results.results[0][1].reasoning)\n```\n\n The word provided is \"repand\" and the letter to count is \"p\". I will examine each letter in the word to see if it matches \"p\". The first letter is \"r\", which does not match. The second letter is \"e\", which does not match. The third letter is \"p\", which matches. The fourth letter is \"a\", which does not match. The fifth letter is \"n\", which does not match. The sixth letter is \"d\", which does not match. Therefore, the total count of \"p\" in \"repand\" is 1.\n\nWhile the model didn't strictly adhere to the example in our instructions, it followed the prompt instructions enough to inspect each letter individually as part of the reasoning process.\n\nImproving the prompt in this manner can be useful in simple examples, but what if you're not exactly sure how to improve the prompt?\n\nDSPy offers an approach called teleprompting where the model use a subset of a labeled dataset for training, evaluate the results with a signature you define, then optimize the results by providing correct examples to the model as part of the prompt as well as rewriting the instructions with the LLM itself to try and improve the results.\n\nWhat I've just described is an approach called [MIPROv2](https://dspy.ai/api/optimizers/MIPROv2/).\n\nLet's try it out with with 150 training examples and 50 test examples (same as our initial set size).\nWe'll use the `count_letter_cot` signature to start with which gives the model space to reason about the problem but doesn't impose the opinionated instructions we added for `count_letter_strategic`.\n\n```python\n# Create train and test sets\n# Split data to ensure no overlap between train and test sets\ndf_shuffled = df.sample(frac=1, random_state=42).reset_index(drop=True)\n\ntrain_data = [dspy.Example(word=row['word'], letter=row['letter'], count=row['count']).with_inputs('word', 'letter')\n for _, row in df_shuffled.iloc[:150].iterrows()]\n\ntest_data = [dspy.Example(word=row['word'], letter=row['letter'], count=row['count']).with_inputs('word', 'letter')\n for _, row in df_shuffled.iloc[150:200].iterrows()]\n```\n\n```python\nfrom dspy.teleprompt import MIPROv2\n```\n\n```python\nmipro_optimizer = MIPROv2(\n metric=letter_count_metric,\n auto=\"light\",\n seed=42\n)\n\nwith dspy.settings.context(lm=gpt_4_1_nano_lm):\n # Optimize the CountLetterCOT module\n print(\"Optimizing with MIPROv2...\")\n optimized_count_letter = mipro_optimizer.compile(\n count_letter_cot,\n trainset=train_data,\n valset=test_data,\n )\n\n mipro_results = evaluator(optimized_count_letter)\n\n\nprint(f\"MIPROv2 optimized results: {mipro_results}\")\n\n```\n\n```text collapse={13-217}\n2025/09/28 17:55:16 INFO dspy.teleprompt.mipro_optimizer_v2:\nRUNNING WITH THE FOLLOWING LIGHT AUTO RUN SETTINGS:\nnum_trials: 10\nminibatch: False\nnum_fewshot_candidates: 6\nnum_instruct_candidates: 3\nvalset size: 50\n\n2025/09/28 17:55:16 INFO dspy.teleprompt.mipro_optimizer_v2:\n==> STEP 1: BOOTSTRAP FEWSHOT EXAMPLES <==\n2025/09/28 17:55:16 INFO dspy.teleprompt.mipro_optimizer_v2: These will be used as few-shot example candidates for our program and for creating instructions.\n\n2025/09/28 17:55:16 INFO dspy.teleprompt.mipro_optimizer_v2: Bootstrapping N=6 sets of demonstrations...\n\n\nOptimizing with MIPROv2...\nBootstrapping set 1/6\nBootstrapping set 2/6\nBootstrapping set 3/6\n\n\n 4%|▍ | 6/150 [00:00<00:02, 57.11it/s]\n\n\nBootstrapped 4 full traces after 6 examples for up to 1 rounds, amounting to 6 attempts.\nBootstrapping set 4/6\n\n\n 3%|▎ | 4/150 [00:00<00:02, 69.03it/s]\n\n\nBootstrapped 3 full traces after 4 examples for up to 1 rounds, amounting to 4 attempts.\nBootstrapping set 5/6\n\n\n 2%|▏ | 3/150 [00:00<00:02, 69.29it/s]\n\n\nBootstrapped 2 full traces after 3 examples for up to 1 rounds, amounting to 3 attempts.\nBootstrapping set 6/6\n\n\n 4%|▍ | 6/150 [00:00<00:02, 71.73it/s]\n2025/09/28 17:55:16 INFO dspy.teleprompt.mipro_optimizer_v2:\n==> STEP 2: PROPOSE INSTRUCTION CANDIDATES <==\n2025/09/28 17:55:16 INFO dspy.teleprompt.mipro_optimizer_v2: We will use the few-shot examples from the previous step, a generated dataset summary, a summary of the program code, and a randomly selected prompting tip to propose instructions.\n\n\nBootstrapped 4 full traces after 6 examples for up to 1 rounds, amounting to 6 attempts.\n\n\n2025/09/28 17:55:16 INFO dspy.teleprompt.mipro_optimizer_v2:\nProposing N=3 instructions...\n\n2025/09/28 17:55:17 INFO dspy.teleprompt.mipro_optimizer_v2: Proposed Instructions for Predictor 0:\n\n2025/09/28 17:55:17 INFO dspy.teleprompt.mipro_optimizer_v2: 0: Count the number of occurrences of a specific letter in a given word.\n\n2025/09/28 17:55:17 INFO dspy.teleprompt.mipro_optimizer_v2: 1: Given a word and a specific letter, analyze and explain how many times the letter appears in the word. Provide a step-by-step reasoning process showing the positions where the letter occurs and then indicate the total count of these occurrences.\n\n2025/09/28 17:55:17 INFO dspy.teleprompt.mipro_optimizer_v2: 2: You are a linguistics researcher analyzing letter patterns in words. Given a specific word and a target letter, carefully reason through the positions of the letter within the word, explaining your thought process step by step. Then, accurately count how many times this letter appears in the word and provide both your reasoning and the total count. Be detailed in your explanation to ensure clarity and transparency.\n\n2025/09/28 17:55:17 INFO dspy.teleprompt.mipro_optimizer_v2:\n\n2025/09/28 17:55:17 INFO dspy.teleprompt.mipro_optimizer_v2: ==> STEP 3: FINDING OPTIMAL PROMPT PARAMETERS <==\n2025/09/28 17:55:17 INFO dspy.teleprompt.mipro_optimizer_v2: We will evaluate the program over a series of trials with different combinations of instructions and few-shot examples to find the optimal combination using Bayesian Optimization.\n\n2025/09/28 17:55:17 INFO dspy.teleprompt.mipro_optimizer_v2: == Trial 1 / 10 - Full Evaluation of Default Program ==\n\n\nAverage Metric: 45.00 / 50 (90.0%): 100%|██████████| 50/50 [00:07<00:00, 6.80it/s]\n\n2025/09/28 17:55:24 INFO dspy.evaluate.evaluate: Average Metric: 45 / 50 (90.0%)\n2025/09/28 17:55:24 INFO dspy.teleprompt.mipro_optimizer_v2: Default program score: 90.0\n\n/Users/danielcorin/dev/dsp-letters/.venv/lib/python3.13/site-packages/optuna/_experimental.py:32: ExperimentalWarning: Argument ``multivariate`` is an experimental feature. The interface can change in the future.\n warnings.warn(\n2025/09/28 17:55:24 INFO dspy.teleprompt.mipro_optimizer_v2: ===== Trial 2 / 10 =====\n\n\n\nAverage Metric: 37.00 / 50 (74.0%): 100%|██████████| 50/50 [00:03<00:00, 13.02it/s]\n\n2025/09/28 17:55:28 INFO dspy.evaluate.evaluate: Average Metric: 37 / 50 (74.0%)\n\n\n\n\n\n2025/09/28 17:55:28 INFO dspy.teleprompt.mipro_optimizer_v2: Score: 74.0 with parameters ['Predictor 0: Instruction 1', 'Predictor 0: Few-Shot Set 4'].\n2025/09/28 17:55:28 INFO dspy.teleprompt.mipro_optimizer_v2: Scores so far: [90.0, 74.0]\n2025/09/28 17:55:28 INFO dspy.teleprompt.mipro_optimizer_v2: Best score so far: 90.0\n2025/09/28 17:55:28 INFO dspy.teleprompt.mipro_optimizer_v2: ========================\n\n\n2025/09/28 17:55:28 INFO dspy.teleprompt.mipro_optimizer_v2: ===== Trial 3 / 10 =====\n\n\nAverage Metric: 48.00 / 50 (96.0%): 100%|██████████| 50/50 [00:09<00:00, 5.50it/s]\n\n2025/09/28 17:55:37 INFO dspy.evaluate.evaluate: Average Metric: 48 / 50 (96.0%)\n2025/09/28 17:55:37 INFO dspy.teleprompt.mipro_optimizer_v2: \u001b[92mBest full score so far!\u001b[0m Score: 96.0\n2025/09/28 17:55:37 INFO dspy.teleprompt.mipro_optimizer_v2: Score: 96.0 with parameters ['Predictor 0: Instruction 2', 'Predictor 0: Few-Shot Set 0'].\n2025/09/28 17:55:37 INFO dspy.teleprompt.mipro_optimizer_v2: Scores so far: [90.0, 74.0, 96.0]\n2025/09/28 17:55:37 INFO dspy.teleprompt.mipro_optimizer_v2: Best score so far: 96.0\n2025/09/28 17:55:37 INFO dspy.teleprompt.mipro_optimizer_v2: ========================\n\n\n2025/09/28 17:55:37 INFO dspy.teleprompt.mipro_optimizer_v2: ===== Trial 4 / 10 =====\n\n\n\nAverage Metric: 37.00 / 50 (74.0%): 100%|██████████| 50/50 [00:04<00:00, 11.10it/s]\n\n2025/09/28 17:55:41 INFO dspy.evaluate.evaluate: Average Metric: 37 / 50 (74.0%)\n2025/09/28 17:55:41 INFO dspy.teleprompt.mipro_optimizer_v2: Score: 74.0 with parameters ['Predictor 0: Instruction 2', 'Predictor 0: Few-Shot Set 4'].\n2025/09/28 17:55:41 INFO dspy.teleprompt.mipro_optimizer_v2: Scores so far: [90.0, 74.0, 96.0, 74.0]\n2025/09/28 17:55:41 INFO dspy.teleprompt.mipro_optimizer_v2: Best score so far: 96.0\n2025/09/28 17:55:41 INFO dspy.teleprompt.mipro_optimizer_v2: ========================\n\n\n2025/09/28 17:55:41 INFO dspy.teleprompt.mipro_optimizer_v2: ===== Trial 5 / 10 =====\n\n\n\nAverage Metric: 37.00 / 50 (74.0%): 100%|██████████| 50/50 [00:00<00:00, 4406.06it/s]\n\n2025/09/28 17:55:42 INFO dspy.evaluate.evaluate: Average Metric: 37 / 50 (74.0%)\n2025/09/28 17:55:42 INFO dspy.teleprompt.mipro_optimizer_v2: Score: 74.0 with parameters ['Predictor 0: Instruction 1', 'Predictor 0: Few-Shot Set 4'].\n2025/09/28 17:55:42 INFO dspy.teleprompt.mipro_optimizer_v2: Scores so far: [90.0, 74.0, 96.0, 74.0, 74.0]\n2025/09/28 17:55:42 INFO dspy.teleprompt.mipro_optimizer_v2: Best score so far: 96.0\n2025/09/28 17:55:42 INFO dspy.teleprompt.mipro_optimizer_v2: ========================\n\n\n2025/09/28 17:55:42 INFO dspy.teleprompt.mipro_optimizer_v2: ===== Trial 6 / 10 =====\n\n\n\nAverage Metric: 37.00 / 50 (74.0%): 100%|██████████| 50/50 [00:00<00:00, 4720.02it/s]\n\n2025/09/28 17:55:42 INFO dspy.evaluate.evaluate: Average Metric: 37 / 50 (74.0%)\n2025/09/28 17:55:42 INFO dspy.teleprompt.mipro_optimizer_v2: Score: 74.0 with parameters ['Predictor 0: Instruction 2', 'Predictor 0: Few-Shot Set 4'].\n2025/09/28 17:55:42 INFO dspy.teleprompt.mipro_optimizer_v2: Scores so far: [90.0, 74.0, 96.0, 74.0, 74.0, 74.0]\n2025/09/28 17:55:42 INFO dspy.teleprompt.mipro_optimizer_v2: Best score so far: 96.0\n2025/09/28 17:55:42 INFO dspy.teleprompt.mipro_optimizer_v2: ========================\n\n\n2025/09/28 17:55:42 INFO dspy.teleprompt.mipro_optimizer_v2: ===== Trial 7 / 10 =====\n\n\n\nAverage Metric: 38.00 / 50 (76.0%): 100%|██████████| 50/50 [00:04<00:00, 10.89it/s]\n\n2025/09/28 17:55:46 INFO dspy.evaluate.evaluate: Average Metric: 38 / 50 (76.0%)\n2025/09/28 17:55:46 INFO dspy.teleprompt.mipro_optimizer_v2: Score: 76.0 with parameters ['Predictor 0: Instruction 0', 'Predictor 0: Few-Shot Set 2'].\n2025/09/28 17:55:46 INFO dspy.teleprompt.mipro_optimizer_v2: Scores so far: [90.0, 74.0, 96.0, 74.0, 74.0, 74.0, 76.0]\n2025/09/28 17:55:46 INFO dspy.teleprompt.mipro_optimizer_v2: Best score so far: 96.0\n2025/09/28 17:55:46 INFO dspy.teleprompt.mipro_optimizer_v2: ========================\n\n\n2025/09/28 17:55:46 INFO dspy.teleprompt.mipro_optimizer_v2: ===== Trial 8 / 10 =====\n\n\n\nAverage Metric: 37.00 / 50 (74.0%): 100%|██████████| 50/50 [00:04<00:00, 10.77it/s]\n\n2025/09/28 17:55:51 INFO dspy.evaluate.evaluate: Average Metric: 37 / 50 (74.0%)\n2025/09/28 17:55:51 INFO dspy.teleprompt.mipro_optimizer_v2: Score: 74.0 with parameters ['Predictor 0: Instruction 1', 'Predictor 0: Few-Shot Set 5'].\n2025/09/28 17:55:51 INFO dspy.teleprompt.mipro_optimizer_v2: Scores so far: [90.0, 74.0, 96.0, 74.0, 74.0, 74.0, 76.0, 74.0]\n2025/09/28 17:55:51 INFO dspy.teleprompt.mipro_optimizer_v2: Best score so far: 96.0\n2025/09/28 17:55:51 INFO dspy.teleprompt.mipro_optimizer_v2: ========================\n\n\n2025/09/28 17:55:51 INFO dspy.teleprompt.mipro_optimizer_v2: ===== Trial 9 / 10 =====\n\n\n\nAverage Metric: 31.00 / 50 (62.0%): 100%|██████████| 50/50 [00:04<00:00, 10.89it/s]\n\n2025/09/28 17:55:56 INFO dspy.evaluate.evaluate: Average Metric: 31 / 50 (62.0%)\n2025/09/28 17:55:56 INFO dspy.teleprompt.mipro_optimizer_v2: Score: 62.0 with parameters ['Predictor 0: Instruction 2', 'Predictor 0: Few-Shot Set 3'].\n2025/09/28 17:55:56 INFO dspy.teleprompt.mipro_optimizer_v2: Scores so far: [90.0, 74.0, 96.0, 74.0, 74.0, 74.0, 76.0, 74.0, 62.0]\n2025/09/28 17:55:56 INFO dspy.teleprompt.mipro_optimizer_v2: Best score so far: 96.0\n2025/09/28 17:55:56 INFO dspy.teleprompt.mipro_optimizer_v2: ========================\n\n\n2025/09/28 17:55:56 INFO dspy.teleprompt.mipro_optimizer_v2: ===== Trial 10 / 10 =====\n\n\n\nAverage Metric: 37.00 / 50 (74.0%): 100%|██████████| 50/50 [00:00<00:00, 3075.77it/s]\n\n2025/09/28 17:55:56 INFO dspy.evaluate.evaluate: Average Metric: 37 / 50 (74.0%)\n2025/09/28 17:55:56 INFO dspy.teleprompt.mipro_optimizer_v2: Score: 74.0 with parameters ['Predictor 0: Instruction 1', 'Predictor 0: Few-Shot Set 5'].\n2025/09/28 17:55:56 INFO dspy.teleprompt.mipro_optimizer_v2: Scores so far: [90.0, 74.0, 96.0, 74.0, 74.0, 74.0, 76.0, 74.0, 62.0, 74.0]\n2025/09/28 17:55:56 INFO dspy.teleprompt.mipro_optimizer_v2: Best score so far: 96.0\n2025/09/28 17:55:56 INFO dspy.teleprompt.mipro_optimizer_v2: =========================\n\n\n2025/09/28 17:55:56 INFO dspy.teleprompt.mipro_optimizer_v2: ===== Trial 11 / 10 =====\n\n\n\nAverage Metric: 48.00 / 50 (96.0%): 100%|██████████| 50/50 [00:00<00:00, 4883.34it/s]\n\n2025/09/28 17:55:56 INFO dspy.evaluate.evaluate: Average Metric: 48 / 50 (96.0%)\n2025/09/28 17:55:56 INFO dspy.teleprompt.mipro_optimizer_v2: Score: 96.0 with parameters ['Predictor 0: Instruction 2', 'Predictor 0: Few-Shot Set 0'].\n2025/09/28 17:55:56 INFO dspy.teleprompt.mipro_optimizer_v2: Scores so far: [90.0, 74.0, 96.0, 74.0, 74.0, 74.0, 76.0, 74.0, 62.0, 74.0, 96.0]\n2025/09/28 17:55:56 INFO dspy.teleprompt.mipro_optimizer_v2: Best score so far: 96.0\n2025/09/28 17:55:56 INFO dspy.teleprompt.mipro_optimizer_v2: =========================\n\n\n2025/09/28 17:55:56 INFO dspy.teleprompt.mipro_optimizer_v2: Returning best identified program with score 96.0!\n\n\n\n\n\n2025/09/28 17:55:56 INFO dspy.evaluate.evaluate: Average Metric: 48 / 50 (96.0%)\n\n\nMIPROv2 optimized results: EvaluationResult(score=96.0, results=)\n```\n\nThe results are just as good as our manual prompt improvements.\n\nSo what did the model do?\n\n```python\noptimized_count_letter\n```\n\n predict = Predict(StringSignature(word, letter -> reasoning, count\n instructions='You are a linguistics researcher analyzing letter patterns in words. Given a specific word and a target letter, carefully reason through the positions of the letter within the word, explaining your thought process step by step. Then, accurately count how many times this letter appears in the word and provide both your reasoning and the total count. Be detailed in your explanation to ensure clarity and transparency.'\n word = Field(annotation=str required=True json_schema_extra={'desc': 'The word to search in', '__dspy_field_type': 'input', 'prefix': 'Word:'})\n letter = Field(annotation=str required=True json_schema_extra={'desc': 'The letter to count', '__dspy_field_type': 'input', 'prefix': 'Letter:'})\n reasoning = Field(annotation=str required=True json_schema_extra={'prefix': \"Reasoning: Let's think step by step in order to\", 'desc': '${reasoning}', '__dspy_field_type': 'output'})\n count = Field(annotation=int required=True json_schema_extra={'desc': 'The number of times the `letter` appears in the `word`', '__dspy_field_type': 'output', 'prefix': 'Count:'})\n ))\n\nIn this case, it looks like the optimizer added specific instructions that seems to result in better performance of the task by the model\n\n> You are a linguistics researcher analyzing letter patterns in words. Given a specific word and a target letter, carefully reason through the positions of the letter within the word, explaining your thought process step by step. Then, accurately count how many times this letter appears in the word and provide both your reasoning and the total count. Be detailed in your explanation to ensure clarity and transparency.\n\nLet's see how this prompt translates into the type of reasoning the model does\n\n```python\nwith dspy.settings.context(lm=gpt_4_1_nano_lm):\n result = optimized_count_letter(word='basketball', letter='b')\n\nresult\n```\n\n Prediction(\n reasoning='The word is \"basketball,\" which contains the following letters: b, a, s, k, e, t, b, a, l, l. I need to find all instances of the letter \"b\" within this word. The first letter is \"b,\" which matches the target letter. The second \"b\" appears as the seventh letter in the word. No other \"b\" characters are present. Therefore, the total count of \"b\" in \"basketball\" is 2.',\n count=2\n )\n\nNot quite the same as the approach we instructed in `count_letter_strategic` but it seems to have achieved the same result without our explicit instructions.\n\nThe model, helped by DSPy, figured this out iteratively, in a self-improving loop.\n\nI'm going to wrap up here but there's more to explore with DSPy.\n\n- Several other [optimizers](https://dspy.ai/learn/optimization/optimizers/)\n- Local models via the [LiteLLM](https://dspy.ai/api/integrations/LiteLLM/) integration\n\nI'll aim to do this in another post soon."},{"type":"log","id":"2025/09/20","title":"2025-09-20","description":"","tags":["claude-code"],"date":"2025-09-20","url":"/logs/2025/09/20","content":"In a pinch, took a shot and found out `claude --resume` is a [real thing](https://github.com/anthropics/claude-code/issues/371)"},{"type":"log","id":"2025/09/14","title":"2025-09-14","description":"","tags":[],"date":"2025-09-14","url":"/logs/2025/09/14","content":"> I think that your point about intuitions and getting intuitions is the big thing. And I think people, we don't realize is when you're dealing with something fundamentally new, you can't trust, like, how you reason about it without experiencing it, because you have to build the intuition in order to be able to reason about what it means and how it fits in and whether it works or not.\n>\n> And we're just not used to that because we're used to reasoning about things we already have an intuition for. And I think that's why, like, when you first see, maybe when you first saw ChatGPT, you'd be like, oh my God, it can do everything. Like, we're not going to have jobs in a year.\n>\n> And now we're like three years in and we're like, yeah, it's awesome. And jobs are complicated. There's a lot of complex stuff that we do\n>\n> -- AI & I: Claude Code Can Be Your Second Brain, Sep 10, 2025\n>\n> https://podcasts.apple.com/us/podcast/ai-i/id1719789201?i=1000725911151&r=2737"},{"type":"garden","id":"language-models/building-with-ai","title":"Building With AI","description":"","tags":[],"date":"2025-09-12T19:13:17.942Z","url":"/garden/language-models/building-with-ai","content":"Everyone these is _building with AI_. Or wants to be. Or telling their employees they need to build with AI. Or shipping with AI. Or putting AI in their products.\n\nBut what are people even talking about when they say you should build or ship with AI? I can think of at least three different approaches that make use of \"AI\" the proverbial way it is being referred to most of the time today and I think they're worth discussing because I rarely hear the difference discussed.\n\n## Interacting with AI to figure things out\n\nLet's say I want to build a website but I've never built a website before.\nI can have a conversation with a language model based chatbot and learn more about how to write HTML, style my site with CSS, and add interactivity with JavaScript.\nI can learn about hosting options like WordPress or Github Pages, depending on my needs and the type of content I want to publish.\n\nThe language model can take my prompts and feedback and steer me in a helpful direction.\n\nThis doesn't work for uncharted territory but it works pretty well for Solved Problems.\nMany people know how to build websites and you can learn to.\nWith a language model, you don't necessarily need to read a book on how to build a website, you can start wherever you want to in the process and the language model can help fill in gaps.\n\nIf you try out the model's suggestions, you'll find a lot of suggestions work and some don't.\nExperimenting like this is a great way to develop an intuition for what the model you are working with can do.\n\n## Using AI to make things\n\nCoding agents like Claude Code and Cursor and \"vibecoding\" products like Lovable and v0 have become popular ways to build software.\nUsing these tools significantly lowers the barrier to entry for building software.\nYou may not build great software, bug-free software, or performant software, but you'll probably build more than you would have without them.\n\nI also find the coding agents helpful for collaboratively building software.\nIf you know how to code, you can use the agent to quickly scaffold boilerplate code, implement architecture patterns, refactor code, and more.\n\nI think there is a wide range over which you can use these tools to build software.\nNot everyone agrees.\n\nEither way, this is a second way to \"build with AI\".\n\n## Building software with AI that does something as part of the product\n\nChatGPT is an example of a product that uses the AI in the experience itself.\nYou send a message to ChatGPT and OpenAI uses your input as the input to their model.\nThey run inference with their model and stream the output to your browser.\n\nThe product experience itself is made possible using the language model or AI (previously more commonly known as machine learning).\n\nTeams building chatbots on top of knowledge bases, Slack bots that answer frequently asked questions automatically, and agents that read your emails and schedule meetings are all examples of products that use AI in a way that is core to the product experience.\n\nSaid differently, these products are made possible using the emergent capabilities of the language model.\nThe prior two examples of \"building with AI\" actually just use AI to do things we did before, but faster and with less friction than before (to say nothing of the tradeoffs of learning how the software works and not understanding your code).\n\nSo the next time someone says \"we're building with AI\", ask them what they mean.\nGetting on the same page will help save a lot of time, energy, and confusion."},{"type":"post","id":"2025/running-a-mile-with-llms","title":"Running a Mile with LLMs","description":"","tags":["language_models","fitness"],"date":"2025-09-10T17:07:06.951Z","url":"/posts/2025/running-a-mile-with-llms","content":"import ChatContainer from '@components/prose/ChatContainer.astro';\nimport ChatMessage from '@components/prose/ChatMessage.astro';\nimport closed from './images/closed.png';\nimport flood from './images/flood.png';\n\nI was not planning on writing about this but after reading Sascha's [post](https://zettelkasten.de/posts/the-scam-called-you-dont-have-to-remember-anything/), I decided it could be interesting because his demonstration on what it takes to build knowledge happened to relate to prompting a language model for a fitness routine:\n\n> This drives us to one of the most important conclusions of the entire field of note-taking, knowledge work, critical thinking and alike: You, not AI, not your PKM or whatever need to build the knowledge because only then it is in your brain and you can go the next step.\n>\n> Let me try to give you a demonstration of the issue:\n>\n> I asked ChatGPT to design an optimal weekly training schedule for health span and fitness.\n\nand then he proceeds to point out how unless you know some things, you have no way to evaluate whether the model's plan is any good, which I agree with.\n\nI went into the following experiment knowing there was a decent chance the language model would give me bad advice.\nI was mostly interested to see what would happen.\n\n# Training for a mile\n\nI used a few different language models to design a training schedule to run a single mile, as fast as I could do it.\n\nI'm a relatively seasoned athlete, so this was nothing like a couch to 1 mile training plan.\nHowever, I've never intentionally trained for a short distance running race.\nI've only ever run as cross-training for other sports.\n\nSo I created a Project with Claude Opus and started to see what a training plan might look like.\n\nHere's an example of asking an LLM to design a training schedule for running a mile.\nI've summarized the assistant responses, but ensured the training session suggestions were true to the original recommendations.\nThe actual model responses were even longer as Claude had a lot to say about these plans.\n\n\n \n Hey I want to train to run a mile in under 6 minutes. Come up with a training plan for me.\n \n\n \n **Phase 1: Base Building (6-8 weeks)**\n\n Build tolerance for short rest intervals safely.\n\n *Main Sessions (2x/week):*\n\n - Start: 4-5 x 400m with 90s rest at sustainable pace\n - Expect 92-96 seconds initially\n - Weekly progress: Add 1 rep OR reduce rest by 5s OR improve pace by 2s\n - Only change ONE variable per week\n\n *Easy Days (2x/week):*\n\n - 20-30 minute conversational-pace jogs\n - Builds aerobic base and aids recovery\n\n **Phase 2: Speed Development (4 weeks)**\n\n - 6-8 x 400m at 86-90s with 60-75s rest\n - Begin only when consistently hitting 90s with 90s rest\n\n **Key Guidelines:**\n\n - Maintain current cycling/weights\n - Take 1-2 complete rest days weekly\n - Start conservatively and progress slowly\n - Keep easy days truly easy\n - Prioritize consistency over intensity\n\n **Success Target:** Complete 8 x 400m at 88-90s with 75s rest consistently before attempting mile time trial.\n\n \n\n\nSo I gave the main sessions a try and they went ok!\nI actually felt like I was ready for a bit more at my fitness level, so time to do some prompt engineering.\n\n## Recalibrating based on my fitness level\n\n\n \n *... stuff about me, recent workout performance, cycling wattage, etc. ...*\n\n Help me come up with a training plan over the next 2.5-3 months to run a 6 minute mile.\n\n \n\n \n Your cycling fitness shows you have the cardiovascular base needed. A 6-minute mile requires holding 10 mph for 6 minutes - we need to build running-specific speed and neuromuscular power over 12 weeks.\n\n Phase 1: Base Building (Weeks 1-4)\n\n **Weekly Structure:**\n - **Monday**: Easy run (30-40 min)\n - **Tuesday**: 6-8 x 400m at 85-90 seconds (90 sec rest)\n - **Wednesday**: Cycling/weights\n - **Thursday**: 20 min tempo at 7:00-7:30/mile pace\n - **Friday**: Rest or easy cycling\n - **Saturday**: Long run (45-60 min easy)\n - **Sunday**: Weights or rest\n\n Phase 2: Speed Development (Weeks 5-8)\n\n **Weekly Structure:**\n - **Monday**: Recovery run (25-30 min)\n - **Tuesday**: Progress to 8 x 400m at 80-85 seconds, then 4-5 x 800m at 2:50-3:00\n - **Wednesday**: Cycling\n - **Thursday**: 3 x 8 min at threshold pace (6:45-7:00/mile)\n - **Friday**: Rest\n - **Saturday**: Progression run\n - **Sunday**: Explosive weight training\n\n Phase 3: Race Prep (Weeks 9-12)\n\n **Weekly Structure:**\n - **Monday**: Easy recovery (20-30 min)\n - **Tuesday**: Race-pace work - progress to 3 x 1200m at 4:30 (5:00/mile pace), then 2 x 1 mile at 6:15-6:20\n - **Wednesday**: Easy cycling/rest\n - **Thursday**: Short tempo or easy run\n - **Friday**: Rest\n - **Saturday**: Time trials (taper in week 12)\n - **Sunday**: Easy run or rest\n\n Key Points\n\n - **Pacing**: Target even 90-second splits per 400m lap\n - **Testing**: Mile time trial every 3-4 weeks (expect 10-15 second monthly improvements)\n - **Recovery**: Maintain cycling, add explosive strength work 1-2x weekly\n - **Taper**: Reduce volume 40-50% in final week while maintaining intensity\n\n With consistent training, your cycling fitness gives you the foundation to achieve a 6-minute mile within 3 months.\n\n \n\n\nLooking back at this plan with the benefit of hindsight, I realized I didn't even bother looking at phase three of the plan, which looks _very_ ambitious to me, even in retrospect.\nTo not spoil the journey, I'll get back to this later.\n\nI let the model know about my recent workout performance to see if it had anything to say about it.\n\n\n \n Last week:\n 90\n 90r\n 90\n 90r\n 89\n 90r\n 88\n 90r\n 91\n\n Today:\n 75\n 90r\n 88\n 90r\n 89\n 90r\n 88\n 90r\n 88\n\n \n\n \n You're ahead of schedule! Your consistent 88-89 second 400m reps show excellent improvement, but that 75-second opener was too fast for this training phase. While impressive, going 15 seconds faster than race pace can compromise your workout and doesn't build the specific endurance needed for a 6-minute mile.\n\n **Next Week's Workout:**\n\n - 6 x 400m at 85-87 seconds\n - Start conservative (87s) for reps 1-2, then drop to 85-86s if feeling good\n - 90-second rest between reps\n\n **2-3 Week Progression:**\n\n - **Week 3-4:** 7-8 x 400m at 83-85 seconds, add weekly 800m time trial\n - **Week 5-6:** 5 x 800m at 2:50-2:55 (key workout for bridging to 6-minute mile)\n\n **Bottom Line:** You likely could run 6:15-6:20 right now with proper pacing. That 75-second speed shows you have the raw ability - focus now is on controlled, sustainable pace. Every rep at 85-90 seconds builds the exact endurance adaptations you need. Save the blazing fast reps for later phases with full recovery.\n\n \n\n\nThe model felt pretty good about my performance.\nI was having some pacing problems and it called that out as well.\nIt even threw out a guess on what my mile time would be if I made an attempt at my current level of fitness.\n\nI was seeing improvements and feeling better in the workouts.\nIt felt like I was on some kind of right track, so I kept at it.\n\n\n \n Here was week 2 from today:\n\n 82\n 90r\n 90\n 90r\n 85\n 90r\n 88\n 90r\n 84\n 90r\n 86\n\n \n \n **Performance Update:** Crushed Week 2 with a 3-second improvement! Week 1 averaged ~89 seconds, Week 2 averaged ~86 seconds. You're showing Week 4-5 fitness ahead of schedule thanks to exceptional aerobic adaptation.\n\n **Next Week Training Options:**\n\n **Option A (Recommended):** 7-8 x 400m @ 83-87 seconds with 75-second rest\n **Option B:** 4-5 x 600m @ 2:10-2:15 with 90-second rest\n\n **Accelerated Timeline:**\n\n - **Week 4:** 8 x 400m @ 82-85s with 60-second rest + 1200m time trial\n - **Week 5-6:** 5-6 x 800m @ 2:45-2:50\n - **First Mile Time Trial:** Week 4 (predicted 6:15-6:25)\n\n **Current Mile Fitness Estimates:**\n\n - Current: 6:20-6:30\n - Week 4: 6:10-6:15\n - Week 8: 6:00-6:05\n - Week 12: Sub-6:00 achievable\n\n **This Week's Focus:**\n\n - Thursday tempo: 6:45-7:00 pace\n - Saturday long run: 7:30-8:00 pace (easy)\n - Add 4 x 100m strides after Monday's easy run\n\n **Watch for:** Achilles/calf tightness and shin splints as speed increases.\n\n The 6-minute mile goal is looking very achievable—possibly by Week 8-9 rather than Week 12!\n\n \n\n\nThis threw me off.\nBased on where I was at, these goals felt very ambitious and I wasn't feeling good about it.\nI assumed the model was painting a rosier picture than reality based on past experience of models making things up and generally being wrong and unreliable about all sorts of things.\n\n## I had doubts\n\n\n \n I need you to be realistic\n \n \n Reality Check\n\n **The Gap:** While your 82-86 second 400m repeats with 90 seconds rest are solid, there's a significant difference between interval work with recovery and holding 90-second laps for 4 consecutive laps without rest.\n\n **Current Fitness Assessment:**\n\n - You can hit 82-86 seconds WITH full recovery\n - 6-minute mile requires 90-second laps WITH NO recovery\n - Realistic current mile time: 6:45-7:00\n\n **Realistic 12-Week Timeline:**\n\n - Week 4: 6:35-6:45\n - Week 8: Breaking 6:30 would be good progress\n - Week 12: 6:10-6:20 is a realistic target\n\n **Sub-6:00 Reality Check:** This is a stretch goal requiring exceptional lactate buffering. Most runners need to comfortably run 75-80 second 400s to break 6:00.\n\n **Today's Session Assessment:**\n\n Your 86-second average with 90 seconds rest shows you're exactly where you should be for Week 2, but the brutal math reveals the challenge: you're running faster than goal pace WITH recovery, while the goal requires slightly slower pace WITH zero recovery.\n\n **Honest Prediction:** Based on current performance, you're tracking toward 6:25-6:35 by Week 12.\n\n \n\n\nHmm ok.\nSo I showed some doubt and the model followed my lead and pulled back where it estimated I would be.\nBy design, I basically had no idea about where I should be, the type of progress I could expect, or whether the initial or secondary predictions were reasonable.\nThe points about rest between intervals made sense considering I didn't have enough experience or knowledge to push back against them.\n\nIt was true that I _would_ need to run 4 laps with no rest.\nAnd that sounded harder than most of the things I had been doing.\n\nSo I continued the plan with more conservative expectations about how performance might improve, still following the second plan the model gave me after I told it my fitness level.\n\n## My first (and only) tempo run\n\n\n \n Tempo\n Target 4800m @ 7 min/1600m pace\n\n 1:45.68\n 1:47.78\n 1:46.58\n 1:46.66\n 1:45.47\n 1:46.62\n 1:47.38\n 1:47.37\n 1:47.79\n 1:48.78\n 1:49.84\n 1:39.24\n\n 21:19.25\n\n \n \n **Current Performance Analysis:**\n\n - Recent tempo run: 1:47 per 400m (7:09/mile pace) with excellent consistency\n - Goal mile pace needed: 1:30 per 400m (6:00/mile)\n - Gap to bridge: 17 seconds per lap\n\n **The Reality:**\n\n Your threshold pace is currently 7:00-7:10/mile. To run a 6:00 mile, you need to run significantly faster than this threshold pace, but only sustain it for 6 minutes instead of 21+ minutes. This 70-second per mile gap is substantial but achievable with 9 weeks of focused training.\n\n **Recommended Weekly Structure:**\n\n **Friday:** Easy 25-minute run + 8 x 30 seconds at 6:00 pace (90 sec easy jog recovery)\n\n **Saturday:** 50 minutes truly easy (7:45-8:15 pace) for aerobic base\n\n **Tuesday:** 8 x 400m with 75 seconds rest, targeting 87-90 seconds per 400m\n\n **Projected Timeline:**\n\n - Current mile fitness: ~6:35-6:40\n - Week 6 projection: ~6:15-6:20\n - Week 12 target: Sub-6:00 (requires perfect consistency)\n\n **Key Focus:** The 400m/800m interval work is critical - it trains the faster energy systems above threshold that you'll need for the mile. Your finishing kick shows you have speed reserve; now we need to bring your threshold closer to race pace through consistent tempo work.\n\n \n\n\nClaude wasn't so enthusiastic about the tempo performance with regard to my chances for a 6-minute mile.\nThe mile time projections at the different week marks were varying all over the place.\n\nBecause the original training plan was further up in the chat (I had this conversation in one long chat), it was a pain to scroll back to the original plan and the model kept suggesting new plans anyway, with different rest durations that were kind of close to the original plan.\nI decided to just ask the model to tell me what the workout was for today and go with that.\n\n\n \n What is today's workout?\n \n \n Today's Workout Summary\n Main Set: 8 x 400m with 60-second rest\n Pacing Strategy:\n\n Reps 1-2: 87-88 seconds (conservative start)\n\n Reps 3-6: 85-88 seconds (find rhythm)\n\n Reps 7-8: Hold on, accept what comes\n\n Expect:\n\n Slower than last week (88-92 is fine)\n Incomplete recovery between reps\n Heavy breathing throughout\n\n Warmup: 10-15 min easy + 4 x 100m strides\n Cooldown: 10 min easy jog\n\n \n \n 8x400m 60r\n\n 85\n 60r\n 89\n 60r\n 87\n 60r\n 88\n 60r\n 89\n 60r\n 90\n 60r\n 91\n 60r\n 90\n\n \n \n **Breakthrough Performance Achieved**\n\n You crushed this week's workout, running 400m repeats at an 88.6-second average with only 60-second rest - just 2.5 seconds slower than last week despite 33% less recovery time. Most athletes lose 5-7 seconds with reduced rest, so this shows exceptional cardio adaptation.\n\n **Current Mile Projection**\n\n - **Current fitness level:** 6:25-6:30 mile (ahead of schedule)\n - **Week 8 projection:** Sub-6:20 very likely\n - **Week 12 goal:** Sub-6:00 increasingly realistic\n\n **Key Insights**\n\n Your ability to hold 88-91 seconds with incomplete recovery proves you can sustain goal pace (90 seconds) when pre-fatigued - exactly what mile racing demands. The minimal fade between first and last rep shows strong lactate tolerance.\n\n **Next Week's Workout (Week 4)**\n\n - **Distance:** 8 x 400m\n - **Rest:** Reduce to 45-50 seconds\n - **Target pace:** 90-93 seconds\n - **Purpose:** Complete cardio adaptation phase\n\n You're ahead of schedule and starting to look like the athlete you remember being. This workout was a statement of your progress toward that sub-6:00 mile goal.\n\n \n\n\nThis was a confidence building session for me.\nI had expected the reduction of rest from 90 to 60 seconds to hit hard and negatively affect my performance.\nThe fact that I was able to continue executing the \"plan\" despite fatigue felt like a big win.\n\nIt seemed like I had exceeded Claude's expectations for me, at least, after I had given it a reason to doubt its initial predictions.\nEither way, it was excited.\n\nAgain, I didn't really consider the implications of the feedback I was giving the model and I was somewhat wary of whether its plans were actually reasonable.\nI definitely wasn't putting blind trust in the plan and was pushing back, but I was also not very informed, so it's not as though I was coming from a position of expertise.\n\n## An unexpected turn\n\nI realized something else on this day as well.\n\n\n\nThe track on the East River was closing on 2025-09-08 for construction work until the [end of 2026](https://evgrieve.com/2025/09/east-river-park-north-of-houston-street.html).\n\n> [RIP. It was a sick track.](https://www.reddit.com/r/RunNYC/comments/1mnm0wf/comment/n85w2ef/)\n\nMy plan had not accounted for this.\nBut I really wanted to give the mile my best shot.\n\nI decided to see what GPT-5 thought I could do to salvage the situation.\nI was going to need all the help I could get to figure out the next 4 days.\n\n\n \n I need to race a mile in 4 days. I am targeting 6 minutes. Here are my most recent workouts.\n\n 2025-08-13\n\n 5x400m 90r\n 90\n 90r\n 90\n 90r\n 89\n 90r\n 88\n 90r\n 91\n\n 2025-08-18\n\n 5x400m 90r\n 75\n 90r\n 88\n 90r\n 89\n 90r\n 88\n 90r\n 88\n\n 2025-08-26\n\n 6x400m 90r\n 82\n 90r\n 90\n 90r\n 85\n 90r\n 88\n 90r\n 84\n 90r\n 86\n\n 2025-08-27\n\n Tempo\n Target 4800m @ 7 min/1600m pace\n\n 1:45.68\n 1:47.78\n 1:46.58\n 1:46.66\n 1:45.47\n 1:46.62\n 1:47.38\n 1:47.37\n 1:47.79\n 1:48.78\n 1:49.84\n 1:39.24\n\n 21:19.25\n\n 2025-09-03\n\n 8x400m 60r\n 85\n 60r\n 89\n 60r\n 87\n 60r\n 88\n 60r\n 89\n 60r\n 90\n 60r\n 91\n 60r\n 90\n\n Give me a plan\n\n \n \n Here's your final prep for Sunday's sub-6:00 mile attempt:\n\n **Thu 9/4**\n - 20-30 min easy run\n - Drills + 4-6 relaxed strides (60-100m)\n\n **Fri 9/5 — Readiness Check: 2 x 800 @ 2:58-3:00, 2:00 rest**\n - Warm-up: 10-15 min easy, drills, 4-6 strides; optional 1 x 200 at ~45 three minutes before\n - Target even splits: 200 in 45, 400 in 90, 600 in 2:15, finish 2:58-3:00\n - Cool-down: 10 min easy\n - Results guide:\n - Green (≤3:00 both): proceed as planned\n - Yellow (3:01-3:03): open slightly conservative\n - Red (≥3:04 or fade): consider delaying race or adjusting to 6:05-6:10 goal\n\n **Sat 9/6**\n - 15-20 min very easy + 4 strides\n - Light mobility, stay off feet otherwise\n\n **Sun 9/7 — Race Day**\n\n *Warm-up (40-50 min pre-race):*\n - 10-15 min easy jog, drills, 4-6 strides\n - Optional: 1 x 200 at ~45 three minutes before start\n\n *Pacing Strategy:*\n - Mile: 45/90/3:00/4:30/finish hard\n - 1600m: 90-89-89-88 (sub-5:58)\n\n *Key Rules:*\n - Don't go faster than 45 for first 200\n - If lap 1 = 92: go 89-89-87\n - If lap 1 = 88: settle to 90-90, kick last 200\n\n *Race Logistics:*\n - Wear your usual fast shoes\n - Eat carb-focused meal 2-3h before\n - Hydrate with 300-500ml water + pinch of salt in final 2-3h\n\n Send me your Friday 2 x 800 times and I'll confirm your exact pacing strategy. You're ready—nail the first lap and everything else follows.\n\n \n \n 2x800m 120r\n 3:04\n 120r\n 3:02\n \n \n Quick mile plan (yellow readiness): open a touch conservative, then squeeze late.\n\n Race pacing\n - Default (1600 m): 91 - 90 - 90 - 88 = 5:59\n - If you open slow (92): 92 - 90 - 89 - 88\n - If you open fast (≤89): settle to 90-91 on lap 2, 90 on lap 3, kick last 300-200\n - Full mile (1609 m): hit 1600 in 5:57-5:58; the extra 9 m is your kick\n\n Checkpoints and in-race adjustments\n - First 200 ≥46; relax, tall posture, light quick cadence\n - 400 ~91 feeling controlled\n - 800 in 3:01-3:03; commit to 89-88 over last two laps\n - Lap 3 cue: hold cadence, \"hips tall, push the ground\"\n - Last 500-300: start squeezing; last 200 go arms-first and commit\n\n Warm-up (start 40-50 min before)\n - 10-15 min easy jog\n - Drills: leg swings, skips, high knees, butt kicks\n - 4-6 strides building to mile effort\n - Optional: 1 x 200 at ~45-46 about 3 min before start\n\n Day-before (easy)\n - 15-20 min very easy + 4 relaxed strides; light mobility; otherwise off your feet\n\n Logistics\n - Wear the shoes you've been doing fast work in; lace securely\n - Carb-centric meal 2-3 h pre-race; optional 15-30 g carb 15-30 min before\n - Caffeine only if you're used to it\n - If windy, tuck on straights, push tailwind sections\n\n Bottom line: Open under control (91), settle, then squeeze. If you're ~3:02 at 800 feeling smooth, 5:59-6:01 is there with a committed last 600-400.\n\n \n\n\nI popped my new plans and tune up 2x800m results over to Claude and its response left me confused.\n\n\n \n 2x800m 120r\n 3:04\n 120r\n 3:02\n \n \n **Your Recent 800m Performance:** 3:04, 3:02 (91.5 seconds per 400m) - excellent pacing with a negative split and strong consistency.\n\n **Key Insight:** You held near-goal pace for 800m, which shows you can maintain the right speed for half your target distance. Your 800m pace (3:00-3:03) is right on target for a 6:00 mile.\n\n **Current Mile Fitness Estimate:** 6:20-6:25\n\n **Next Steps for 800m Training:**\n - **Next time:** 3 x 800m at 3:00-3:05 (2 min rest)\n - **Week after:** 4 x 800m at 3:00-3:05 (90s rest)\n\n **The Challenge:** To run a 6:00 mile, you need to hold these 800s back-to-back without rest. Currently you're completing 800s with 2:00 rest - the goal is eliminating that recovery time while maintaining pace.\n\n These 800m workouts are arguably more important than 400m repeats for your mile goal, as they build the speed endurance needed for your target time.\n\n \n\n\nSince I had had the conversation about the shortened timeline outside this thread, Claude didn't know what I was talking about.\nI had two days left and I was going to race on 2025-09-07.\n\nClaude seemed to think I had 6:20-6:25 pace potential given the 2x800m workout.\nGPT-5 thought I could be within a few seconds of 6:00.\n\nI wasn't sure what to think.\nI definitely wished I had more time and had run more 600m and 800m workouts.\n800m felt very different from 400m the way I was trying to run them.\n\nI had gone from 90s rest between 400s to 60s to 0s for the 2x800m.\nThat workout was tough, though I think my pacing could have been better.\n\nSo I felt sort of in the dark at this point.\n\n## Race day\n\nI woke up Sunday morning on 2025-09-07 and it was raining.\nI went through a pretty standard race prep routine I have.\nI eat a banana and make sure I am awake several hours before the race.\n\nAfter sitting around for about two hours, the rain actually let up, so I went down to the track to do my warmup, planning to just race in the rain if I had to.\n\nI had finished my dynamic warmup and was starting to do strides when I saw this.\n\n\"The\n\nWell not actually this.\nWhat I saw was water midway through the fifth lane of the track.\nI took this picture after everything was done and 20-30 minutes more draining.\nIf it had only been this bad, I probably wouldn't have changed much, but at the time, it was so flooded I had to adjust.\n\nI decided to run the race in lane 6.\nI did some quick [research](https://www.everydayhealth.com/workouts-activities/what-is-the-distance-around-a-running-track-for-each-lane/) on my phone, and found I needed to do (1600 / 438.33) 3.65 laps.\n\nI sized up the final corner before the last 100m, took the midpoint of the turn (0.125+ 0.50 = 0.625) and added a little bit to that.\nThat would be my finish point on the fourth lap.\n\nIt was hacky but I was going to try and make it work.\n\nI went over to my normal starting spot, went out to lane 6, and off I went.\n\n## There's a reason you don't want to be in lane 6\n\nRunning in lane 6 was weird.\nThe turns are longer and I couldn't pace myself at all since I didn't know the target 200m or 400m times with the adjusted number of laps.\n\nIt was not an optimal setup.\nPerfect weather though, minus the wet.\n\nI ran the race a bit conservatively through the first half and had a decent amount left in the tank to push the last 1.65 laps.\n\nI clocked the finish at 6:11.\nI was a bit surprised when I saw it.\n\nI was sure I'd started too conservatively to put up 6:00, but 6:11 felt like a pretty good result.\n\nI did take a look at the stopping point and decided it was probably a touch short of 1600m.\nSo I'm going to call it a 6:15.\n\n## Reflecting\n\nLooking back on this process, one thing that surprised me was something Claude said on 2025-08-26\n\n\n \n **Current Mile Fitness Estimates:**\n\n - Current: 6:20-6:30\n - Week 4: 6:10-6:15\n - Week 8: 6:00-6:05\n - Week 12: Sub-6:00 achievable\n\n \n\n\nI didn't know it at the time, but roughly two weeks later I would attempt the mile and finish with a time right in the range Claude predicted.\nThis was _before_ Claude recalibrated its prediction based on my prompt to \"be realistic\" that same day.\nThat said, Claude made plenty of other predictions in the neighborhood of my goal, so it isn't so surprising it got one of them right.\n\n## Takeaways\n\nIt seemed like Claude might have had a better sense of my capabilities than I did.\nHowever, when I showed uncertainty, it went with me.\nMaybe it should have pushed back.\n\nI'm not sure how I would prompt for that, avoiding leading it to adjust its predictions to be less ambitious, if its pattern matching suggested its plan could actually be possible for me to execute.\n\nMaybe it was all a coincidence.\n\nI think there's a chance I might have performed better on a nicer day.\nBut it's equally possible I might have started too aggressively and then faded too much.\n\nUnfortunately, I won't have the chance to find out but I'm glad I got to give this a shot before the track closed.\nMaybe it's for the best.\nI'll need to do some proper research to learn if Claude was proposing reasonable plans for me."},{"type":"log","id":"2025/09/08","title":"2025-09-08","description":"","tags":[],"date":"2025-09-08","url":"/logs/2025/09/08","content":"The world is vast and deeply detailed.\n\nIf you build an ever more detailed physical model of the world's topography, eventually you end up with a map the size of the world itself[^1].\n\nMaps and models allow us to think and see and reason about broad concepts and how they interact with each other.\nThis is the difference between seeing a bag of marbles as\n\n```\nblue 🔵\nblue 🔵\nred 🔴\ngreen 🟢\nblue 🔵\n```\n\nand another bag as\n\n```\nred 🔴\ngreen 🟢\ngreen 🟢\nblue 🔵\nred 🔴\ngreen 🟢\n```\n\nand the more abstract concept that bag one has a most common color of \"blue 🔵\" and bag two of \"green 🟢\".\n\nStatistics are a common example of compressing reality into an abstraction that can more easier be reported and compared against.\nMode (described above) is a relatively lossy statistic.\nWe could prefer something like color counts instead.\n\n```\nHand one\n🔴 red: 1\n🟢 green: 1\n🔵 blue: 3\n```\n\nThat's more information than just the mode.\nWe know about other colors and their rate of occurrence.\n\nBut we still don't know their position in the bag.\nWhether any overlapped each other.\nWhich colors were touching which.\nWhat the size and weight of the marbles were.\n\nThe level of detail that can potentially be captured to describe this bag of marbles continues down to an identical replica of the true physical state.\nThis brings us back to the beginning of this essay.\n\n## All models are wrong\n\nBut some are useful[^2].\n\nWhen creating models or reporting statistics, you need to decide which elements of the situation must be captured and which can be neglected without compromising the clarity of the abstraction or description of the situation.\n\nIn the case of the marbles, if we're just trying to describe the “marble-color” population, it could be ok to neglect the position of the marbles in the bag or their size.\nBut when we read that data of the counts of the colors of the marbles, often implicit in our reading can be implied sameness across other characteristics of those marbles.\n\nWhen I devised this example I imagined all the marbles were the same weight, size and made of the same material.\nBut a dataset of counts of marbles and their colors doesn't imply that.\nThe statistic has its focus and neglects the rest.\n\n## Models in writing\n\nWriting is a means by which you can transfer an idea from your head into someone else's.\nYou have to decide which data points, which statistics, which models you include in your writing in your attempt to conjure your idea within the mind of the reader.\n\nDifferent examples will be effective for different readers.\nIt's the writers job to mark these paths for readers.\nNot every path will be taken, but many can lead to the same place.\n\nMaybe my \"bag of marbles\" analogy example didn't land for you.\nI could present another analogy or model that might.\nI could present several.\n\nBut too many models or examples and readers will lose sight of the point of the writing.\n\n## What you don't write\n\nYou also have to decide what you aren't going to write about.\nMore so, even.\n\nThere are so many things you could write about, and you have to decide what to leave out.\n\n[^1]: https://en.wikipedia.org/wiki/On_Exactitude_in_Science\n\n[^2]: https://en.wikipedia.org/wiki/All_models_are_wrong"},{"type":"log","id":"2025/09/07","title":"2025-09-07","description":"","tags":[],"date":"2025-09-07","url":"/logs/2025/09/07","content":"import { Tweet } from 'astro-embed';\n\nTwo separate people texted me that OpenAI finally added conversation branching to ChatGPT.\n\n\n\nThe implementation is quite basic and doesn't make the different branches visible, but it's nice to see it added nonetheless.\nAfter working on [Delta](/projects/delta), I never quite sure what the best UX for the feature was.\n\nShortly after, I was this tweet from John\n\n\n\nSo, on to the next one."},{"type":"log","id":"2025/09/04","title":"2025-09-04","description":"","tags":[],"date":"2025-09-04","url":"/logs/2025/09/04","content":"I met up with a friend the other day who is a software engineer in between roles.\nWe were talking about the future of the job and the field more broadly.\nWith the popularization of language models it feels like the ways we work and assumptions we've held are being upended, and not for the first time.\n\nI personally believe the job description of \"software engineer\" is going to continue to mean and entail a greater diversity of skills than ever before.\n\nSoftware engineers (even prior to them being called as such) have always provided instructions to computers and tried to organize both the instructions and computers in such a way that an intended task could be accomplished by using that software through an interface to the computer.\n\nThis has not changed.\n\nWhat has changed are the breadth and complexity of areas in which an individual building software needs to participate."},{"type":"log","id":"2025/09/03","title":"2025-09-03","description":"","tags":["codex","gpt-5"],"date":"2025-09-03","url":"/logs/2025/09/03","content":"I tried OpenAI's `codex` CLI coding agent again today for the first time in a _while_.\n\n```sh\nUpdate available! 0.1.2504301751 → 0.29.0.\n```\n\nI recently shipped a release of [Tomo](https://www.wvlen.llc/apps/tomo) but there was a minor bug with the horizontal scrollbar overlapping a codeblock with syntax highlighting.\n\nI prompted `codex` to fix this and it seemed to localize the problem and suggest a working fix in one attempt.\n\n> ensure that the horizontal scrollbar in styled codeblocks does not overlap the code itself. right now I am seeing that behavior\n\nI was motivated to try this out because I've been hearing rumblings about `gpt-5` being good at coding.\nIt's currently the number 4 coding model on OpenRouter and climbing, relative to both Sonnet and Qwen3 Coder.\n\n| Rank | Model | Company | Parameters | Performance |\n| ---- | --------------------- | --------- | ------------ | ----------- |\n| 1 | Grok Code Fast 1 | x-ai | 844B tokens | ↑ 3,231% |\n| 2 | Claude Sonnet 4 | anthropic | 339B tokens | ↓ 9% |\n| 3 | Qwen3 Coder 480B A35B | qwen | 112B tokens | ↓ 33% |\n| 4 | GPT-5 | openai | 66.2B tokens | ↑ 21% |\n| 5 | DeepSeek V3.1 | deepseek | 60.9B tokens | ↓ 56% |\n\nI believe Grok Code Fast 1 was launched in some kind of free capacity along with its release which may in part explain its high usage but we will see where that lands."},{"type":"til","id":"anthropic/custom-slash-commands-hierarchy","title":"Claude Code Custom Slash Commands Hierarchy","description":"","tags":["claude-code","slash-commands"],"category":"anthropic","date":"2025-09-02T18:49:42.561Z","url":"/til/anthropic/custom-slash-commands-hierarchy","content":"Claude Code supports [custom slash commands](https://docs.anthropic.com/en/docs/claude-code/slash-commands#custom-slash-commands).\n\n> Custom slash commands allow you to define frequently-used prompts as Markdown files that Claude Code can execute. Commands are organized by scope (project-specific or personal) and support namespacing through directory structures.\n\nThis feature reminds me of my experiment using [Goose as a task runner](/posts/2025/goose-as-a-task-runner), where writing a markdown spec in a `.goosehints` file is sufficient to get the agent to execute a task.\n\nClaude Code provides native support for these \"slash commands\" as well as support for arguments.\nIf you find yourself prompting in a similar way often, a custom slash command may be a good fit to save you some typing.\n\nWhile there are lots of interesting ways to use this feature, today I learned about how they apply hierarchically between the home folder and within your project and its subfolders.\n\nLet's consider the following custom slash command\n\n```md title=\"~/.claude/commands/hello.md\"\nSay \"hello from home dir\"\n```\n\nIf we fire up `claude` in an empty folder, we see the following when we prompt `/hello`\n\n```sh\n╭───────────────────────────────────────────────────────────────────────────────────╮\n│ > /hello │\n╰───────────────────────────────────────────────────────────────────────────────────╯\n /hello Say \"hello from home dir\" (user)\n```\n\nNow, let's add a custom slash command in the project folder.\n\n```md title=\"./.claude/commands/hello.md\"\nSay \"hello from project dir\"\n```\n\n```sh\nclaude\n```\n\n```sh\n╭───────────────────────────────────────────────────────────────────────────────────╮\n│ > /hello │\n╰───────────────────────────────────────────────────────────────────────────────────╯\n /hello Say \"hello from project dir\" (project)\n```\n\nThe slash command defined in the home folder is overridden by the one we defined in the project folder.\n\nNow, let's add a custom slash command in a subfolder of the project.\n\n```md title=\"./subfolder/.claude/subfolder/hello.md\"\nSay \"hello from subfolder\"\n```\n\n```sh\nclaude\n```\n\n```sh\n╭───────────────────────────────────────────────────────────────────────────────────╮\n│ > /hello │\n╰───────────────────────────────────────────────────────────────────────────────────╯\n /hello Say \"hello from project dir\" (project)\n /subfolder:hello Say \"hello from subfolder\" (project)\n```\n\nWe see both slash commands, with the one we just added showing up under the namespace.\n\nSay we also want the commands from our home directory and want to avoid naming collisions with the project commands.\nWe can do that by symlinking the home commands into the a subdirectory in the project.\n\n```sh\nmkdir -p .claude/commands/home && ln -sf ~/.claude/commands/* .claude/commands/home/\n```\n\n```sh\nclaude\n```\n\n```sh\n╭───────────────────────────────────────────────────────────────────────────────────╮\n│ > /hello │\n╰───────────────────────────────────────────────────────────────────────────────────╯\n /hello Say \"hello from project dir\" (project)\n /home:hello Say \"hello from home dir\" (project)\n /subfolder:hello Say \"hello from subfolder\" (project)\n```\n\nThe `/hello` command from the home directory now shows up under the `home` namespace as a project command.\nHowever, since it is a symlink, any changes to the `~/.claude/commands/hello.md` file will be reflected in the project commands the next time we start `claude`.\n\nThat is a reasonable setup but what if you work in a monorepo and want to be able to use `./.claude/commands` from the root of the project in subfolders of the project?\n\nGiven our setup above, for starters, let's run `claude` in the `subrepo` folder.\n\n```sh\ncd subrepo\nclaude\n```\n\n```sh\n╭───────────────────────────────────────────────────────────────────────────────────╮\n│ > /hello │\n╰───────────────────────────────────────────────────────────────────────────────────╯\n /hello Say \"hi from home dir\" (user)\n```\n\nAs expected, only the `/hello` command defined in `~/.claude/commands/hello.md` is available.\nTo get the same commands to be available in the subfolder as in the root of the project, we can symlink the `./.claude/commands` folder into the subfolder (`./subrepo/.claude/commands`).\n\n```sh\ncd subrepo # if you haven't already\nmkdir -p .claude/commands && ln -sf \"$(realpath ../.claude)\" .claude\n```\n\n```sh\nclaude\n```\n\n```sh\n╭───────────────────────────────────────────────────────────────────────────────────╮\n│ > /hello │\n╰───────────────────────────────────────────────────────────────────────────────────╯\n /hello Say \"hello from project dir\" (project)\n /subfolder:hello Say \"hello from subfolder\" (project)\n /home:hello Say \"hello from home dir\" (project)\n\n```\n\nIf we inspect the files, we can see the symlink in place as we expect.\n\n```sh\ndev/cc-commands/subrepo\n❯ ls -l -R -A\nlrwxr-xr-x@ - danielcorin 2 Sep 19:55  .claude -> /Users/danielcorin/dev/cc-commands/.claude\n```\n\nWith this approach, any changes to the source folder are also reflected in the symlinked folder, which keeps everything in sync.\n\nThis seems to be the current state of the world with Claude Code, but it would be nice if there were better [monorepo support](https://github.com/anthropics/claude-code/issues/2365), similar to how the tool [supports](https://docs.anthropic.com/en/docs/claude-code/memory#how-claude-looks-up-memories) looking for `CLAUDE.md` files.\n\nWith symlinks, there are a few different approaches that can smooth over the rough edges while Anthropic decides how or if they want to support cascading commands."},{"type":"log","id":"2025/09/01","title":"2025-09-01","description":"","tags":[],"date":"2025-09-01","url":"/logs/2025/09/01","content":"An interesting learning about the iOS Clock alarm app's time picker.\nIt [turns out](https://old.reddit.com/r/interestingasfuck/comments/1n5lztw/the_time_picker_on_the_iphones_alarm_app_isnt/) it's a long list rather than a circular buffer.\nScrolling to the bottom of all three picker lists positions the time at 4:39pm."},{"type":"log","id":"2025/08/31","title":"2025-08-31","description":"","tags":[],"date":"2025-08-31","url":"/logs/2025/08/31","content":"Our approach to applying the intelligence of language models is inside out.\n\nProviding a model access to a number of tool calls and expecting the model to correctly select a tool given a scenario then invoke the tool properly given the surrounding context goes too far for the pattern to be generically useful.\nThere are examples of agents of this type that are effective, but they are effective specifically because they are tested in the scenarios in which they are useful.\nAttaching tools to a model and calling inference in a loop is only a starting point.\nFrom here, refinement is needed to build something consistently reliable and useful.\n\nThe context the agent sees much be managed.\nThat includes the tool calls that are made available to the agent.\n\nThe result may look something like a harness bespoke to the model, an evaluation set with measurable outcomes, and a process for verification either by a human or another model.\n\nTo draw some contrast, constrained, structured, verifiable inference becomes a building block on top of which any type of software system can be built.\nSpecifically, given an input does the model reliably produce the known, expected output?\n\nExisting software systems can be engineered to be durable and reliable.\nModel inference is inherently probabilistic.\nThe more leeway you give a model to make a decision on behalf of the user or the system, the more likely there is for long tail failures of the system.\n\nFor example, let's say your business has a rule where if a customer uploads a document of type A, or two documents, one of type B and another of type C, then the user can proceed to the next step.\n\nThe classical implementation of this type of workflow in software would be to create a form that allows the user to upload their documents, then create a task in some kind of system for a human to review.\nFrom there, if the documents are deemed sufficient given your company's policies by the human reviewer, the user can proceed.\nIf the documents are not sufficient, the user needs to be notified with (hopefully) some clarification of what is missing and the process repeats.\n\nThe challenges with this approach are multifold.\nIt's slow for the user since they need to wait for a human to review their documents before they can proceed.\nIt's expensive because it requires the time, training, and expertise of a human to perform review.\nIt can be error prone and inconsistent because it's difficult to ensure homogeneous judgement across diverse human evaluators and humans inevitably make mistakes, especially when performing many similar tasks in a row or when they're put under pressure to do a certain quantity under time constraints.\n\nLanguage models show promise for solving these types of challenges but architecting a solution that can produce a good result to speed up this process and improve on the quality of the document evaluation requires a thoughtful approach to architecting the software system.\nAI does not appear to be a silver bullet that makes the problem disappear without thought or effort."},{"type":"log","id":"2025/08/28","title":"2025-08-28","description":"","tags":[],"date":"2025-08-28","url":"/logs/2025/08/28","content":"Fiddling around with an [`/activity`](/activity) page for the site."},{"type":"log","id":"2025/08/27","title":"2025-08-27","description":"","tags":[],"date":"2025-08-27","url":"/logs/2025/08/27","content":"Experimenting with activity sparkline concept\n\n![Activity Sparkline](images/sparkline.png)"},{"type":"log","id":"2025/08/26","title":"2025-08-26","description":"","tags":["claude-code"],"date":"2025-08-26","url":"/logs/2025/08/26","content":"A sad morning for Claude Code.\nAmp is mostly working though.\n\n```\n> you there?\n ⎿ ⧉ Selected 1 lines from README.md in Cursor\n ⎿ API Error: 500 {\"type\":\"error\",\"error\":{\"type\":\"api_error\",\"message\":\"Overloaded\"},\"\n request_id\":null}\n```\n\n```\n ⎿ API Error (529 {\"type\":\"error\",\"error\":{\"type\":\"overloaded_error\",\"message\":\"Overloaded\"},\"request_id\":null}) · Retrying in 1 seconds… (attempt 1/10)\n```\n\n---\n\nI tried to create a CSS package to add browser styles with the look and feel of Mac OS 9.\nI thought it would be as simple as showing a coding agent some screenshots of Mac OS 9.\nIt was not.\n\n---\n\nAlso played around with building some Mac OS 9 styled components in CSS.\n\n![Mac OS 9 styled text editor window](images/macos9.png)"},{"type":"log","id":"2025/08/25","title":"2025-08-25","description":"","tags":[],"date":"2025-08-25","url":"/logs/2025/08/25","content":"I had a bit of inspiration and started working on adding code syntax highlighting to Tomo.\n\nSeeing an increasing number of folks running coding agents like Claude Code in loop and with `--dangerously-skip-permissions`.\nYou can accomplish a lot like this with the proper setup.\nIn my experience, the agent needs to be able to evaluate and test its own work to be successful with this approach.\n\nI don't think I would attempt this without using some kind of sandbox for the agent as exploits are becoming increasingly common and advanced."},{"type":"log","id":"2025/08/20","title":"2025-08-20","description":"","tags":[],"date":"2025-08-20","url":"/logs/2025/08/20","content":"> Before LLMs, provided that your team did some of their due diligence, you could always expect to have some help when tackling new code-bases. Either a mentor, or at least some (even if maybe partially outdated) documentation. With LLMs, this is gone. The only thing you can rely on is on your ability to decipher what a highly imperfect system generated, and maybe ask explanations to that same imperfect system about ~~your code~~ its code (oh, and it has forgotten everything about the initial writing process by then).\n>\n> -- https://www.mindflash.org/coding/ai/ai-and-the-bus-factor-of-0-1608\n\nThis article is fair and relevant commentary on the practicing of thoughtlessly producing code to solve a problem without ever reading it.\nHowever, I disagree with this passage's assertion that \"you could always expect to have some help when tackling new code-bases\".\nAt this point in my career, the majority of the codebases I've worked in have required that I learn parts of the system from zero, effectively as if there was no one with any knowledge of the system (aka bus factor of 0).\n\nPractically speaking, even if there actually are some people with knowledge of the system, it may be impractical to rely on them to get you up to speed on a codebase where you need to make some change.\nI've found the most success through figuring things out with the aim to unblock myself.\n\nThis approach _may_ only go so far.\nYou may be able to create and merge a PR but not deploy.\nOr deploy but not know how to run migrations.\nBut the more experience I've had working as a software engineer, the more relevant and useful doing the archeological work of digging through the history of a codebase has been."},{"type":"log","id":"2025/08/19","title":"2025-08-19","description":"","tags":["connections","language_models"],"date":"2025-08-19","url":"/logs/2025/08/19","content":"import Chat from '@components/prose/Chat.astro';\nimport connectionsImage from './images/connections.png';\n\nIt's been a while since I've attempted to use LLMs to solve Connections puzzles.\n\nIn the past, I used a [harness](https://github.com/danielcorin/llm_connections) and allowed the LLM to guess one group at a time with logic that would check if the guess was correct or valid.\nThis approach was closer to how humans play the game and helped `claude-3-5-sonnet` get ~40% of the puzzles correct over [32 games](https://github.com/danielcorin/bots-doing-things/blob/main/content/posts/connections/_index.md).\n\nToday, I took a screenshot of the puzzle and sent it to `gpt-5` and `claude-4-1-opus` (with not tools enabled) with the prompt\n\n