Base Models

YouHaveToReadTheOutput

2026-03-07T23:29:51.331Z

Every. Single. Line.

At every stage of the process

Because garbage in == garbage out

I have used LLMs to do a lot of different kinds of things. Generating text, generating code, summarizing text, doing deep research, parsing data, you name it.

It has made shit up at some point on every single one of those tasks.

If you're going to put your name on it, you'd better know what it says. You'd better know that it's correct. (Not just plausible.) You'd better be willing to stake your reputation on it. Because if something makes it through, that can have real-world-consequences.

Always expand the thinking blocks to see what "reasoning" it used to come to its conclusions.

Often you'll find some bit of flawed reasoning, or a "fact" without a source, that will affect the reasoning and logic of everything that follows.

Effect chain types

Linear

A therefore B therefore C therefore D.

graph LR
A-->B-->C-->D
classDef bad stroke:red,stroke-width:2px;
class B,C,D bad

If B isn't quite right, then C might also be wrong, and therefore D might be wrong.

Example: LLM recommends a dated coding pattern that's not compatible with the latest versions of various libraries, which then causes untraceable dependency hell trying to figure out why a feature isn't working.

Generative Infection Spread

graph LR
A-->B
A-->C
B-->D
B-->E
B-->F
C-->G
C-->H

classDef bad stroke:red,stroke-width:2px;
class B,D,E,F bad

Real-life example: When generating detailed requirements for a feature, the LLM invented a feature it thought logical that nobody asked for, and it affected a big chunk of the architecture and subsequently generated code, tests, and documentation.

Tainted Aggregate Result

graph LR

A-->B-->X
A-->C-->X-->W
Y-->Z
A-->D-->W-->Y
A-->E-->V
A-->F-->V-->Y

classDef bad stroke:red,stroke-width:2px;
class B,X,W,Y,Z bad

Example: In the thinking traces of a deep research task, the LLM took some speculative marketing copy as fact, which led it to classify a bunch of other products as inferior because they lacked the nonsensical feature.

Every single one of these can have real-world consequences, in misinformed purchasing decisions, missed deadlines and increased project costs, or egg one's face when the customer discovers your mistake.

How to read every line efficiently

I'm still figuring this part out.

But it's clear that the more you foresee potential consequences of an output, the more carefully you should be reading it.

Reading early outputs closely can also uncover missed MeatspaceContext that will dramatically affect the quality and usefulness of your end result.

A good SocraticMode planning process will hopefully help you uncover these earlier in the process.

My Current Workflow (Nov 2025)

I’m using mostly Claude Code, with auto-approvals turned off. I use a cute little app called Claudio that uses Claude Code hooks to play different sounds based on different events, like reads, writes, tool uses, and most importantly, approval requests.

I’ll make a plan, tell it to proceed with implementation , the listen for the appropriate beep^[1] to know that it’s time to approve something.

Then I’ll read that particular edit, and either approve it, which is most times, or give it better steering on where it’s gone astray.

It’s definitely slower than YOLO mode, but if I’m writing code that is going to production, or that must be correct, better safe than sorry. It’s rare that I make it through a string of edits without it needing some correction or clarification, even with the best reasoning models. If the edits themselves are sufficiently long, then the very act of making the edits is enough to stretch the context beyond its ability to remain coherent.

Steering helps, but sometimes you have to ABC - Always Be Compacting or just DeclareContextBankruptcy and start fresh.

For anything beyond the simplest task, you should be using FileSystemMemory to record the design and the reasoning and context behind it.

footnote: as always, this post is 100% human-written.

Unfortunately Claudio’s default macOS sounds are crap—the sound doesn’t match the severity level at all. I’ll post my sound scheme here at some point. ↩︎

Words I Hate in AI

2026-02-23T05:27:19.216Z

(AI and adjacent)

Meaningless, misleading, credulous, or just tired. If you see these words, hold on to your wallet:

____ Driven Development (PromptDrivenDevelopment, SpecDrivenDevelopment, AgentDrivenDevelopment) (new 2026-02-22)
"AI Native"
Agentic
Supercharge/Turbocharge
10x / 100x
Automate Your Workflows
Founder
Hacker

What is this thing?

2025-09-29T04:31:09.599Z

Well, first, it's kind of like a wiki, in that it's Hypertext, and the original wiki WikiWikiWeb, which had pages based on concepts, with hypertext linking between them, hearkening back to its predecessor, HyperCard. (This site, unlike many wikis, is not user-editable.)

This site is a hyperlinked concept map, representing my interconnected understanding of and opinions about all things AI (and AI-adjacent).

The companion Substack, Model Behaviors, is sort of a digest of new and edited pages from this site, along with some more essay-like material. Many of the outgoing links in the Substack posts point to pages/concepts on this site, and allows readers to dive deeper into topics of interest that would be repetitive to include in the newsletter.

I'm thinking about how best to solicit ideas and feedback; for now, you can DM me on Substack or email josh (at) joshwand.com.

Written in Obsidian and published with the Digital Garden plugin.

SlopDetection

2026-08-08T07:14:02.587Z

aka LLMogisms

Current AI-written documents have a certain "smell" to them that make it very clear that it was written by AI.

Here's a list of shibboleths that I've found to be reliable indicators of AI authorship.

Pattern Example	Regular Expression
—	`—`
X → Y → Z	`→`
X + Y	`\w \+ \w`
It's not just X. It's Y.	`(stead of\|n't\|not) just.+?(\.\|—)`
X. No/Never Y.	`[—\.;] (Just\|No\|Never\s)`
10k+ Xs.	`[0-9]k?\+`
X itself.	`itself`
that framing really resonated	`framing`
Here's why X works:	`t*here's(.){3,50}[\.—:]`
Why This Works/Matters	`Why (.){3,20} (works\|matters)`
zero Xs.	`zero\s`
The X is the Y.	`the ([^\s]+){1,3} is the ([^\s]+){1,5}\s*[—:\.;]`
clicked/resonated	`(clicked\|resonated)`
(number)-layer	`([0-9]+\|one\|two\|three\|four\|etc)-layer`
the X layer	`the ([^\s])+ layer`
the key/critical insight:	`the (key\|critical) ([^\s])+`
the real/honest X	`the (real\|honest) ([^\s])+`

[the] honest ...
load-bearing
invariant
landing

And to detect AI-generated code defects:

would
in production
assume

PersistentContext

2025-09-29T04:46:56.359Z

(aka: documentation)
(aka: memory - but that's more complicated)

If your AI is an Amnesiac Intern or Junior Developer, they're going to need onboarding to your project. Since every fresh batch of Interns or new team members starts with a blank slate, you need re-usable onboarding material.

The form that material takes will vary by the kind of work you're doing. It could be:

Information about your company and products
Customer personas
System architecture
Team norms and processes
Style guide (your company's, or your personal style)
Brand guidelines

Point is, the AI needs this context in every new conversation, so keep it someplace handy.

There are many ways of organizing it.

Coding Tools

In AI the AI coding space, this was pioneered by the Cline Memory Bank, which I've adapted to my own MentalModel.

Some people would like you to put this in a single file (or one per directory) called AGENTS.md, or CLAUDE.md

ChatGPT and Claude

Projects. (TK)

PeriodicReminders

2025-08-22T02:13:23.923Z

If you have a set of constraints that the AI has to operate under, phrase them somewhere as a brief list. Periodically, repeat the list of instructions in your message:

Please rewrite the next section of my resume, keeping in mind:
• Each bullet point must fit on a single line
• Each bullet point must begin with an action verb
• Where possible, quantify the impact to the business

This applies equally to important context—restating your goals every once in a while will help keep the AI on track.

NewConversationWithSummary

2025-12-06T21:15:29.235Z

[!NOTE]
2025-12-06: I've started to notice multiple agents starting to refer to this as a "handoff". We'll see if the industry settles on a term.

Keep conversations short and focused; handoff to a new conversation often

If your conversation starts to get too long, you run the risk of losing important stuff. When you’ve strayed further and further afield of your original task, or the conversation is just very very long, it’s time to start a new conversation.

You don’t have to start from scratch, though! Ask the AI for a summary of your conversation up til now (or your current working draft, working decisions, etc.), including all relevant facts and details, so that a new chatbot would be able to continue without any additional context. You can collaborate with the AI on the handoff document if you think it’s left something out or got something wrong.

NamedRules

2025-09-29T04:29:30.116Z

Many tools like ChatGPT allow you to personalize your assistant by adding a set of instructions that get applied to every conversation.

If you have certain conventions, rules, or standards that you always want your AI to follow, list them here.

There's no guarantee the LLM will follow them, especially once the the conversations get long. Occasionally, the AI will need to be reminded about a particular rule. To make this easier, I create a easy-to-type name for each rule, so I can just tell the AI exactly what rule it’s failed to follow.

Example:

## NoSyntheticData

**Definition**: If you encounter a problem when working with data, NEVER fall back to some fake or simplified data. You can do this in a test in order to debug the issue, but NEVER use fake data in non-test code.

[Examples of violations]

If I catch the AI oversimplifying the problem by using a contrived example, I can simply reply “NoSyntheticData” and it will know exactly what it did wrong and make the appropriate correction. (You can also combine this with the “Go Back in Time” technique, and simply append it as a reminder (“don’t forget: NoSyntheticData”) to your previous request that generated the bad behavior.

This works because LLMs have been optimized for “Needle-in-a-Haystack” use cases—retrieving relevant facts from earlier content. (This optimization is to make something called “RAG” work well. Future post to come.) It might not proactively remember the rule on its own, but if you remind it, it can retrieve and re-state it to bring it to the front of its mind, so to speak.

credit to normalnormie on the Cursor Forum for the idea.

My Coding Rules

2025-12-18T07:53:46.461Z

https://github.com/joshwand/coding-agent-rules

Wherein I put my ideas into practice.

Incorporates:

GoBackInTime

2025-09-12T16:34:57.632Z

When working with LLMs, I often end up on “side quests”—back-and-forths as I try to figure something out with the AI’s help, or how to phrase something in a way the AI “understands”. This risks distracting the AI with the details of the side conversation, rather than the main substance. Here’s a simple technique to prevent the AI from getting distracted: when you get a response that you don’t like, instead of having an extended dialogue to clarify it**, go back end edit the previous message**, adding clarifications or caveats. If the AI still makes a mistake, add that as an additional condition to your original message.

Alternately, if you do end up on a tangent that yields an interesting insight, scroll back to the point in the conversation where you wish you’d had that insight, and restart your conversation from there—edit the first side-tracking message to continue the conversation with your newfound knowledge.

ABC - Always Be Compacting

2025-09-29T04:29:16.998Z

in the context of a coding assistant, most apps now have a conversation compaction function (Claude Code's /compact, RooCode's "Intelligent Context Compression", etc.)

Equivalent to NewConversationWithSummary, but with a single command. That said, you will have limited control over the contents of the summary when you use the AI tool, whereas if you do it manually, you can revise it as you go.

SemanticToolWrapper

2025-11-30T17:43:23.507Z

Instead of asking a reasoning model to read, say, an entire webpage, we wrap the tool call in a smaller faster model that distills the page content into a lean semantic structure: data + actions

Input:

<html>
<script>...300kb</script>
<body>
<h1>giant webpage</h1>
<a href=""><button onClick="save()">save</button></a>
<a href=""><button onClick="edit()">edit</button></a>

<more><markup>

(useful data)

The small model turns this into:

data: {"some":"useful data"},
available_actions: ["save", "delete", "edit", "next", "previous"]

Which is what our reasoning model works with. No extraneous tokens diluting the core meaning.

There is, of course, a risk of misinterpretation, hallucination, and a loss of information fidelity, but perhaps the tool call could specify a level of detail or some other instructions/context about what it expects to see.

The small model needs a very good prompt, and the correct context from its caller so it is primed for a good semantic interpretation of the raw content.

Web browsing is the obvious usecase, but really it can be the result of any tool call.

Any time you're getting back raw data from a tool call, if it's not already formatted for consumption by the model, it should be wrapped in something that has enough context to transform it so the calling model only ever sees the distilled data.

TK state machine / graph traversal

c.f. hypercard, choose-your-own-adventure, text-based dungeon crawlers

mirrors how brain turns raw visual data, memories, etc, into a mental model.

TK TODO we used to parse unstructured data into strongly-typed data structures, since data structures were the atoms of computing. now we parse the unstructured data into LANGUAGE / SEMANTIC atoms, since that's the atom of LLM reasoning.

LLM said:

Instead of agents getting:


<html><head><title>...lots of irrelevant markup...
<div class="navigation">...menu items...
<div class="job-listing">Senior Engineer at Acme Corp</div>

...ads, footers, tracking scripts...

They get:

BrowserState(
    scene_description="Senior engineering role with competitive compensation",
    available_actions=["easy_apply_button", "save_job"],
    state_data={"job_title": "Senior Engineer", "salary": "$150k-200k"}
)

It'd be an interesting experiment to have it output something that literally looked like a dungeon-crawler of the problem-space:

You are on a job listing page for a senior engineering role at CompanyX. It contains the following data: [xxxxx]

Do you: a) easy_apply_button, b) save_job, or c) something else?

RubberDuck

2025-11-30T17:42:29.921Z

Try to explain your problem to a rubber duck, and the process of formulating the explanation will lead you to possible solutions. ^[1]

This is one of the best uses of AI chat. I use it to explore and refine ideas, along with SocraticMode, as the process of talking it through helps me find areas I haven't explored, or challenges my assumptions.

Some people like to explicitly add "challenge my assumptions" to their initial prompt for this kind of thing, though I haven't yet found the need to.

Hunt, Andrew; Thomas, David (1999). The Pragmatic Programmer: From Journeyman to Master. Addison Wesley. ISBN 978-0201616224. p. 95, footnote. ↩︎

RecencyBias

2025-09-29T04:29:19.101Z

Why AI Forgets

During [training](How LLMs Work), when performing the "how good was our guess" adjustment, the system doesn't give the same weight to all the words in the sequence:

It gives higher importance to the most recent words:

What that means, in practical terms, is that the longer your conversation, the less influence the earlier content has.

To guess the next word, the LLM primarily focuses on the most recent words. Most model training also add extra weight to the beginning of the conversations, to try to preserve your initial intent or instructions. What gets ignored is actually the middle of a long conversation:

Combatting Recency Bias

If you have a set of constraints that the AI has to operate under, phrase them somewhere as a brief list. Periodically, repeat the list of instructions in your message:

Please rewrite the next section of my resume, keeping in mind:
• Each bullet point must fit on a single line
• Each bullet point must begin with an action verb
• Where possible, quantify the impact to the business

This applies equally to important context—restating your goals every once in a while will help keep the AI on track.

Many tools like ChatGPT allow you to personalize your assistant by adding a set of instructions that get applied to every conversation.

If you have certain conventions, rules, or standards that you always want your AI to follow, list them here.

Example:

## NoSyntheticData

**Definition**: If you encounter a problem when working with data, NEVER fall back to some fake or simplified data. You can do this in a test in order to debug the issue, but NEVER use fake data in non-test code.

[Examples of violations]

credit to normalnormie on the Cursor Forum for the idea.

MemoryPatterns

2026-05-04T05:39:42.828Z

Basic patterns

Key-value-index
Episodic
Opportunistic accumulation
Distilled profile/preferences
Dump everything in a vector db and pray

Coding-specific patterns

single-file (in repo / in agent)
single-file-per-module (nested)
my mental model

Upkeep

Dangers of drift
Distillation
Pruning
Paging

Advanced

Knowledge graph
Customer 360
Hermeneutic
Adaptive schema

MeatspaceContext

2025-12-18T07:57:44.883Z

MeatspaceContext is the context that lives in the minds of humans, or in the physical world, that is not digitized (and is often undigitizable).

This is the kind of context that AI will make some default assumptions about, and which, if incorrect, can have major impacts on the usefulness of its [output](YouHaveToReadTheOutput).

Examples of MeatspaceContext:

[!NOTE]
These apply equally to:

other people

organizations

you.

Demographics
Location
Physical environment
Policies
Politics
Culture
Experience
History
Evolution
Values
Attitudes
Beliefs
Priorities
Plans
Goals
Allies
Competitors
Partners
Relationships
Secrets
Strengths/weaknesses

Think of whatever the last thing you did using AI. What assumptions do you think it made about these [aspects](KnowledgeGranularityAndLenses)? What did it get right or wrong? How do you think that affected the output?

LiveNotes

2026-08-08T07:17:11.548Z

2026-08-08 00:09
LLMogisms - "load-bearing", "landed", "shipped", emdashes—I'm starting to wonder if these are just RLHF artifacts or if they are the beginnings of the LLM's internal language leaking out? Are these terms "load-bearing", holding a richer semantic meaning to the LLM greater than we might assign it? A shorthand?

LLM core use cases

2026-02-23T05:27:19.178Z

An evolving catalog. #taxonomies

Generating End-use Content

e.g. Marketing copy, sales pitches, websites

Parsing Unstructured Data

Documents to data e.g. invoices, receipts

(Vision models for getting text out of pdfs and images )

Classifying

Sentiment analysis
Poor man’s switch statement

Summarizing

Emails, meeting transcripts, customer feedback, long documents,

RAG - fact retrieval

Knowledge base look up
Look up data in other systems (order status, travel itinerary, customer record), but this is borderline Agentic AI Agents

Deep Research

This is actually agenting and summarizing.

Data analysis (uses python)

Writing assistant

Brainstorming / [rubber-ducking](RubberDuck)

How LLMs Work

2025-09-29T04:29:30.114Z

How ChatGPT and other AI chatbots work.

ChatGPT, Claude, Grok, and other chatbots are powered by Large Language Models (LLMs). They are trained on [huge volumes of text](Training Data), primarily scraped from the internet.

All LLMs Do is Guess the Next Word, Over and Over

What follows is a extreme simplification of a complex and evolving science. Don't take it too literally. ¯_(ツ)/¯_

Large Language Models (LLMs) are essentially sequence generators—or, put another way, next-word1 guessers. They take a sequence of text (your prompt and whatever context you give it), and based on how often it’s seen that sequence in its training data, its job is to predict what the best next word will be:

The models are trained on vast amounts of text—sequences of words. Billions of articles, webpages, books, code, documentation, blogs, and now, huge datasets of human conversations with LLMs. The training starts with taking a certain length of text, and hiding the last word. The training program takes its best guess at what the hidden word is, based on all the other times it's seen the prior sequence:

It then judges how far off its guess was from the actual target word, and (hand wavey math 👋🧙‍♂️) adjusts the probability, either up or down, whether next time, given a similar sequence, it should or should not use the word it guessed.

Then it adds the guessed word to the sequence, slides forward, and does the whole thing again, including the new word:

Training a LLM from scratch means doing this calculation many trillions of times.

(For coding models, it's a little more involved, and involves guessing the word based on both the words before and the words after the target.)

When a LLM responds to you, it evaluates all those probabilities for the input sequence, which includes the entire conversation thus far, including the current response being generated, and picking the most likely next word. Then, sticking that word at the end, it does the probability calculation again. And again. This is why you get your responses in a stream, one word at a time.

All of this in service of getting their next-word guesses as close as possible to what they’ve seen in their training data. A 100% accurate LLM, in theory, would exactly reproduce the most likely sequence from its training data.

Why AI Forgets

Going back to training, however, when performing the "how good was our guess" adjustment, it doesn't give the same weight to all the words in the sequence:

It gives higher importance to the most recent words:

What that means, in practical terms, is that the longer your conversation, the less influence the earlier content has.

see: RecencyBias

ConversationContainer

2025-11-30T17:57:50.339Z

This is the "harness" which orchestrates all the interaction between LLMs and... anything else.

It's powered by regular-old computer code, and it's responsible for

Setting up the connection to the LLM, including the SystemPrompt, including instructions and a list of available tools
Handling input (often, but not always, from a human)
Executing the actual requests to the LLM, wherever it's hosted
Handling the response, which usually comes as a stream of chunks of data (of various types)
Responding to that data in various ways:
Streaming it back to the user-facing application
Executing a tool
Returning control to the user
Sending a new request to the LLM (might not be the same one), often via PromptChaining.
Handling conversation state

It's important to understand that all your interactions with the LLM are mediated by some application or set of applications that actually execute that interaction.

The LLM conversation itself is just data—request (including the conversation up til the current token), and response (the tokens coming back from the LLM).

Base Models (Home)

2026-05-04T04:57:24.945Z

welcome to my ai thoughts wiki
(What is this thing?) (Who writes it?)

Last updated: 2026-08-08

Essays (on Substack)

Why AI Forgets

AGENTS.md gets it wrong in 2 ways

Strategies

Explainers

All content on this site is 100% human-written. About the Author

Agentic AI Agents

2026-02-23T05:36:14.749Z

Disambiguation:
Agentic AI (this page) - Large Language Models that have the ability to call tools, choose which tools to use to achieve a goal, and react to the results (often by calling more tools).
Personas -

Do you keep hearing that buzzword "AI Agent", or worse, "Agentic", and wonder what the hell it means?

It's not a user-facing "agent" like customer service (except when it is).

What makes an LLM Agent Agentic is :

It has access to a menu of tools it can use- edit a file, query a database, search the web, launch nukes.
It's provided a bunch of context about the task, the operating environment, relevant external data, and the list of available tools.
The agent then operates in a loop:
1. Given the current conversation, it chooses one of the following actions:
2. Keep thinking/talking
3. Return control to the user
4. Use a tool
5. It uses the tool, passing any necessary parameters (a "tool call")
6. The tool result is added to the conversation.
7. Goto 1.
8. or: decide there's no more work to do with its current task (both success and failure)

Return control to the user

How it works:

LLM can “speak” a special phrase - the tool call
it runs in a ConversationContainer listening for tool calls
The container executes the tool and “tells” the LLM the result by adding it to the conversation.

Agent examples :

ChatGPT decides to use a web search tool to get more information
A customer service chatbot looks up your order in the order system
A coding assistant reads/writes your files or runs your code
Anything that calls a MCP server

It's important to recognize that the tool call result may not be the end of the response—the LLM looks at what it got back, and predicts what the next token should be—some “thinking”, or commentary, or summary, or another tool call, or a “end of turn” token.

You can end up with a very long chain of tool calls.

Memory is often a tool call. Save memory, search memories, etc.

There can be many layers of agents, or multiple agents working as a team—there are tons of different architectures.

Importantly there’s a distinction between a single LLM token sequence of text, and tool calls simply executed by the ConversationContainer, vs an orchestrator (another type of ConversationContainer) that runs more deterministic logic around the calls (cf Claude code hooks),

Or multiple models validating or reacting to the inputs and outputs of the tool calls (is this an approved tool call? Is there a security risk hiding in there?)

About the Author

2025-09-29T02:11:32.264Z

Josh Wand - Oakland, CA
Engineer and Product Manager for ~20 years
AWS, Macy's, Gap, Williams-Sonoma, & more

https://linkedin.com/in/joshwand/

josh (at) joshwand.com

AI Coding Tools

2026-05-04T05:25:02.399Z

My personal taxonomy of AI coding tools (and patterns). #taxonomies

They all use the same foundation models and fundamental Agent Loop, but differ in a few aspects:

SystemPrompt
How they invoke tools
How they apply changes
User interface
Where they run
Pricing model

Many are starting to produce their own First-Party models, though they are usually just post-training on top of available OpenWeightModels.

Note: many of the below tools now offer multiple interfaces—IDE, CLI, and cloud-based

IDE-based

Integrated Development Environment—a desktop app for coding. AI coding chat in a sidebar.

Cursor, Windsurf, VS Code Copilot, Augment, Cline, RooCode, Github Copilot, Kiro, Antigravity, Ampcode, Kilocode...

CLI-based

Command-line interface.

Examples:
Claude Code, OpenAI Codex, aider, Kiro CLI, QwenCoder, Gemini CLI

Cloud Agents

These run in the cloud, checkout your Github repo, do some work, then file a PR.

Examples:
Cursor, Github Copilot, Jules, Codex, Claude Code for Web

Vibecoding Platforms

These run entirely on the web, and will not only build your app but also run it and let you publish it to the world, as one integrated tool. You typically sacrifice a degree of control, like the ability to efficiently manually edit the code, in exchange for the simplicity of the direct chat-to-app flow.

Examples:
Lovable (I remember when it was GPT-Engineer), Bolt, v0, Emergent, base44, Replit... there's dozens more

Multi-worktree independent workers (whack-a-mole)

You set multiple agents to work, each doing one task, within the same codebase, working in isolated git worktrees on separate branches, so they don't step on each other.

You can do this yourself with tmux, but there are also many tools to help manage the process, such as Conductor, Vibe Kanban, Claude Squad, and ccmanage; Github / VS Code are also adding features in this direction.

The Ralph Wiggum Loop

Cargo-Cult Multi-Agent Complexity

e.g. Gastown

Base Models

YouHaveToReadTheOutput

Every. Single. Line.

At every stage of the process

Because garbage in == garbage out

Effect chain types

Linear

Generative Infection Spread

Tainted Aggregate Result

How to read every line efficiently

My Current Workflow (Nov 2025)

Words I Hate in AI

What is this thing?

SlopDetection

PersistentContext

Coding Tools

ChatGPT and Claude

PeriodicReminders

NewConversationWithSummary

Keep conversations short and focused; handoff to a new conversation often

NamedRules

My Coding Rules

GoBackInTime

ABC - Always Be Compacting

SemanticToolWrapper

RubberDuck

RecencyBias

Why AI Forgets

Combatting Recency Bias

MemoryPatterns

Basic patterns

Coding-specific patterns

Upkeep

Advanced

MeatspaceContext

Examples of MeatspaceContext:

LiveNotes

LLM core use cases

Generating End-use Content

Parsing Unstructured Data

Classifying

Summarizing

RAG - fact retrieval

Deep Research

Data analysis (uses python)

Writing assistant

Brainstorming / [rubber-ducking](RubberDuck)

Meta:

agenting

Non-deterministic general purpose compute unit

How LLMs Work

How ChatGPT and other AI chatbots work.

All LLMs Do is Guess the Next Word, Over and Over

Why AI Forgets

ConversationContainer

Base Models (Home)

Recently Updated

Essays (on Substack)

Strategies

Explainers

Agentic AI Agents

About the Author

AI Coding Tools

IDE-based

CLI-based

Cloud Agents

Vibecoding Platforms

Multi-worktree independent workers (whack-a-mole)

The Ralph Wiggum Loop

Cargo-Cult Multi-Agent Complexity