Questioning randomness: the making of a Dada film
Process notes for a Dada film about randomness, made with animation, sound, storyboarding and image-editing tools.
Lynn Cole / 标签
LinkedIn archive
A thread through the work.
What a tiny desktop agent is good at
A tiny desktop model is not equally good at everything. My tests separate useful automation, tagging and summaries from the reasoning tasks where it struggles.
When the value moves upstream from the code
When code becomes cheap to replace, more of the value and responsibility moves into requirements, planning and validation.
Tool descriptions need continuity across loops
A curated tool list is only the start. Agents also need discovery and project notes that carry tool instructions into the next loop.
Gibberish, crawler traps, and the anti-AI web
Scrambling web text creates a cipher and exposes its visual key. I contrast that approach with a crawler honeypot that records visitors to a forbidden endpoint.
Rethinking Glamin around learned embeddings
Mutable vector indexes made Glamin programs too easy to break and too hard to debug. Learned embeddings offer another path for the experiment.
Weekend notes: software distribution, painting controls, and Petrolina
Weekend notes on software distribution, Kinetic Painter’s control system, software reconstruction, recursive training and a new donor truck for Petrolina.
Field notes on software reconstruction and a new donor truck
Field notes on reconstructing complex software and finding a donor truck to keep the talking-vehicle project alive.
Ruby Tumbler: guarding implementation identity
Ruby Tumbler’s next performance problem lives between methods: guards, dynamic dispatch, fallback and the cost of preserving implementation identity.
Recursive training: preparing a third corpus
Preparing a third recursive-training corpus means separating conflicting objectives and testing the order in which the student learns them.
A self-hosted DeepSeek security audit
A self-hosted DeepSeek audit checks templates and generated applications for malicious behavior, separating observed quality problems from the malware question.
Why give a digital fruit fly a memory?
A digital fly already has memory circuitry. I am connecting that machinery to synthetic storage to explore what it remembers and how it learns.
What AI makes possible for independent builders
AI criticism goes in cycles, where the same people repeat the same arguments like they thought of them.
The software you fall in love with
Some software becomes more than a workflow. It becomes an experience people love, share and want beside them at work.
Why I added an operator-reassurance layer
A long-running agent that works silently can look frozen. Progress narration became a necessary part of the product, even when the underlying work was going well.
Git-native collaboration without another walled garden
Git distributes code; Hubnot distributes the signed collaboration around it. The operational alpha has already used its own protocol to merge changes.
Planning a self-play experiment for a coding model
A planned self-play experiment uses compiler verification and multiple reviewers to turn a small Qwen model into a stronger Go developer.
Agents A1 and Qwen: coding-workflow observations
A coding-workflow comparison of Agents A1 and Qwen finds different failure modes across Go, Zig and Next.js, and a useful response to QA feedback.
Expose capabilities, not a frontier model
Expose useful product capabilities instead of embedding an open-ended frontier model. Let users bring the inference stack they already trust.
Finding Qwen’s limit on a vague Zig assignment
A deliberately vague Zig assignment pushes Qwen through planning, implementation and the complexity wall. The failure is part of the evaluation.
Shmoosh: controllable attention before dramatic speedups
Shmoosh’s early speed gains are modest, but its attention policies expose useful control over image quality and performance.
Underpaint and a collaborative painting room
Underpaint combines inpainting, outpainting, prompting, detailing and refinement with a plan for collaborative painting sessions.
Reading code metrics in context
Lines of code mean more when read alongside completed features, deletions, commit hygiene and the conversion of activity into working software.
Context shaping is an engineering skill
Context shaping is more than delegation: iteration, problem solving, manual rewrites and interfaces designed around people.
Evaluating a long-horizon solver with Pizza Empire
Pizza Empire tests a long-horizon coding swarm against a whole product: ordering, kitchen workflow, delivery and the constraints that make them coherent.
A coding-agent demo is not yet a product
A coding-agent demo can complete a task. A product needs to understand arbitrary codebases, resolve ambiguity and recover without constant babysitting.
Underpaint’s document-scoped prompt memory
Underpaint’s Proompt Manager keeps reusable prompts within the scope of a document, tying the painting workflow to its existing session history.
My coding agent is arguing with the ticket system
My coding agent is arguing with its ticket system. Persistent roles and procedural memory create unexpected standards—and a useful kind of bureaucracy.
Building in public as rational self-interest
You build in public to share your notes with like-minded developers, collaborators, and potential employers.
An evaluation process that stopped to announce it had started
An evaluation stopped to announce that it had started. Restarting it exposed a concurrency failure in the project’s database architecture.
What a GitHub chart hides about evaluation work
A GitHub contribution chart hides planning, research and branch-based evaluation work. Low commit volume does not mean low effort.
Proactive agents need richer toolsets
Proactive agents need more than another assistant framework. Build richer tools around a clear problem and a specific reason to exist.
After OpenClaw: continuity, memory, and the agent economy
After OpenClaw, the harder problem is continuity across hours, days and weeks. The opportunity is to let people bring their agents to better tools.
A powerful local model and a very hot Spark
A powerful local Qwen model meets a DGX Spark that runs uncomfortably hot. This is my experience with the original unit and its replacement.
Agent safety starts with how authority is arranged
Agent safety starts with where authority, secrets, backups and deployment permissions live. An agent should never have enough loose authority to destroy the company.
A coding-agent hardening checklist
A coding-agent hardening checklist: model support, hooks, scheduling, tooling, skills and observability, with the remaining integration work still in flight.
Toward a model-agnostic coding-agent release
Preparing a model-agnostic coding-agent release exposes the difference between a supported tool protocol and a model that can complete the workflow.
Changing the runtime layer and rebuilding the interface
Changing the model runtime led to a scheduler rewrite, document ingestion and interface work—and added another five days to the project.
A correct theorem can still target the wrong system
A correct theorem about a narrow multi-agent abstraction does not settle the value of systems with persistent state, tools and fresh environmental feedback.
Reading layered context-control surfaces in Claude Code
A review of Claude Code’s layered context-control machinery: prompts, hidden reminders, tool serialization and parallel permission decisions.
The expensive part is the trial and error
Copying an existing agent harness can be fast. Discovering and handling its real failure modes is where the engineering time goes.
BitNet and Qwen in a bounded coding evaluation
A bounded coding evaluation pits BitNet against a smaller Qwen model. The results expose the difference between cooperative language and working code.
Remembering CodeCharge’s global and local views
CodeCharge’s global, layout and data views made a memorable model for generating applications. I miss that way of seeing the work.
Predictions for 2026, written in December 2025
My predictions for 2026, written in December 2025: small models, edge compute, changing tooling, creative technology and the structures of power.
What an agent’s ticket system really needs
Stripping project management down for agents reveals an interesting question: what is the irreducible minimum structure needed for coordinated work?
Agentic browsing and protected browser state
Agentic browsing should preserve the browser’s security boundaries. Extracting passwords, cookies and session state into model context changes the whole risk.
We have had the vibe-coding argument before
We have heard the vibe-coding argument before—in digital art, visual programming, web design, music and animation. Lowering the barrier changes who gets to try.
Engineering the conditions for automated work
The velocity AI creates in coding is interesting because it is not nearly as uniform as people assume.
When outputs become cheap, taste still matters
When outputs become cheap, organizational abstractions start to lose their grip. Governance, memory and taste remain.
Personas, repository instructions, and alignment
Personas can encode beliefs and boundaries without turning repository instructions into a tax code. Instruction mass changes how agents work.
GLM 4.6: fluid workflows and convincing mocks
A week with GLM 4.6 exposed a fluid creative process, strong QA and convincing mocks, alongside loops and destructive summarization.
WOVEN x26 and the wall of multi-project builds
WOVEN x26 hit a multi-project build wall. A return to Go and the Panda Protocol brought the focus back to labeling and context clarity.
Reasoning bandwidth and recursive depth
Reasoning bandwidth and recursive depth explain failures that token counts alone do not. Context and task complexity need case-by-case treatment.
When an AI-generated voice becomes an instrument
A generated voice can melt directly into an instrument. I enjoy the strange precision of that effect, even when it complicates a live-performance illusion.
Designing a voice agent for embodied use cases
Building a voice agent into a surplus truck makes embodied use cases tangible: sensors, routes, memory, local inference and a constantly changing speech stack.
Two questions before building an AI application
Before building an AI app, answer two questions: why use AI, and what are you optimizing for? Dirty, adaptive problems offer a different value proposition from rigid workflows.
Early-adopter costs on the DGX Spark
The DGX Spark offers a huge shared-memory workspace, but early adoption comes with missing dependencies, difficult setup and a stubborn software ecosystem.
The local creative-computing landscape
My prediction for local creative computing centers on efficiency: reasoning per gigabyte, better device architecture and smaller models that do more.
Voice, multimodality, and lessons from a weekend build
Weekend lessons from voice, multimodal inference, certainty scoring, image stacks and tool instructions trained into small LoRAs.
Reasoning loops as an engineering process
Reasoning loops belong in the engineering process as well as the weights. Spend more time when uncertainty and consequences justify it.
The internet after the advertising model
The internet has changed from an information network into an advertising machine. I see a return toward lighter interfaces and an agent-mediated network.
Five years of learning to build coding agents
Five years of building coding agents led from GPT-2 experiments through Klara to modern tools. Human intent and engineering discipline still shape the result.
Toward Sporkle: a compute-framework progress note
A Fortran compute-framework experiment reaches strong CPU benchmarks while GPU and mesh networking remain explicitly mocked.
Try a better process before another training run
Before paying for another training run, inspect the process: clean inputs, explicit steps and properly labeled tool results solve a different class of problem.
A working taxonomy of hallucination failures
A working taxonomy of hallucination failures, centered on alignment, reward signals, role separation and the software around the model.
The coming collapse of the AI factory: a prediction
A prediction about the economics of AI factories: local models and cheaper edge hardware will eat the cloud.
Designing a deliberately vague agent evaluation
A deliberately vague evaluation tests whether a coding agent can build, audit, document and revise an application without constant micromanagement.
Learning engineering through AI-assisted generation
Learning with AI-assisted generation can be a way into engineering. Build, question the output, document the process and discover what better means.
A small local agent: part bookkeeper, part oracle
Blossom12 gives an agent associative memory behind a ticket-system interface, with a tiny local model doing the bookkeeping and recall.
Mocks, refinement, and what a bug is telling you
Mocks can disappear from an agent’s memory after compaction. Detailed epics help—and bugs remain valuable information about the structure you actually built.
Lessons from a weekend inside an inference engine
A weekend inside an inference engine reveals device middleware, data shaping and old architectural assumptions that still deserve to be challenged.
Busy 10b: webhook stability and command clarity
Busy 10b’s webhook server works, but the client remains unstable. Connection management and clearer process boundaries come next.
Bigger embeddings are not automatically better search
Bigger embeddings do not automatically mean better retrieval. Match the corpus, chunking, context and search architecture to the job.
MCP: usability, abstraction, and scaling costs
My critique of MCP’s abstraction, security and scaling costs, and why some of its use cases remind me of FastAPI.
Consolidating conversation archives into long-term memory
Conversation archives become a long-term memory system through summaries, keywording, weighting and a path back to the original details.
Documentation debt is still infrastructure debt
Documentation debt is still infrastructure debt. AI makes the habit easier, and information silos remain an expensive way to look busy.
Code volume, scope drift, and the human interruption
High-volume generation creates QA and scope-control problems. Tests, milestones and explicit constraints matter more as the code arrives faster.
Prompt augmentation versus deliberate context design
Deliberate context design means separating user intent, memory, tools and instructions rather than packing them into a noisy prompt.
Cleaner signals before larger models
Clean data, explicit structure and useful scaffolding matter before larger models. Better weights are not a substitute for a legible task.
What behaviors are you rewarding in an agent?
What behavior does your agent’s reward system encourage? Composite goals and visible progress can keep the game aligned with the actual work.
Klara’s Spire: a working-memory visualization
Klara describes the Busy context system as an impossible city: a central spire, rolling windows, bridges and a quantum tambourine.
What noise painting is trying to do
Noise painting uses hand-crafted adversarial inputs and incongruent prompts to push diffusion into unexpected visual territory.
Choosing a first language for modern engineering
Choosing a first language means thinking about syntax, transferable skills, setup, longevity and the culture of its community.
Vibe coding and the upstream work of quality
Vibe coding moves more of quality upstream into requirements, prompts and validation, while giving more people a way to try building.
The old engineering work inside the new workflow
The familiar engineering work—planning, patterns and review—still lives inside the new AI coding workflow.
Unstated architecture is still a developer’s responsibility
Architecture that remains unstated is still the developer’s responsibility. Models, prompts, frameworks and modular design all need deliberate choices.
Busy’s complexity wall and changing deployment assumptions
Busy’s complexity wall led through Lua, Dart and a tunneling problem to a different deployment model—and a redesign of the plumbing.
Building around the amnesia problem
An early plugin-based client tackles the amnesia problem with small replaceable components, validations and interruptible command chains.
Teaching the coding system what good means
Tell a coding system what good means: your architecture, standards, metaphors, file boundaries and expectations for documentation.
Enterprise software’s cognitive pipeline
Enterprise software can learn from marketers: target the information, respect cognitive resources and build engagement into the workflow.
Management is more than giving orders
Good management balances accountability, protects attention and builds a collaborative team. It is much more than giving orders.
An early position on AI art, music, and evidence
An early position on AI art and music: separate corporate training practices from artists’ work, and investigate the data before deciding what it demonstrates.
Teaching automated QA to reason about scope
An automated QA system began losing track of scope as output accelerated. Formal documentation and a specialized management tool became the next step.
A context-infrastructure stack for Claude
Happy Trees, logic maps and current-state reports form a context-infrastructure stack for longer, more coherent Claude coding sessions.
Formal coding practices and a self-bootstrapping workflow
Building Grimes became an experiment in formal coding standards, logic maps and a self-bootstrapping agent workflow.
Procedural structure and context in music generation
Music generation needs structural context: songwriting, orchestration and genre combinations grounded in more than a tag list.
Video workflows built around deliverables
A video-generation experiment organizes work around deliverables rather than isolated renders, while optimization exposes the shape of the model pipeline.
Hardening the coding agent across models and integrations
Hardening a coding agent means fixing integration seams, recertifying models and making the same workflow hold across providers.
What Glamin taught me about AI-native language design
Glamin taught me that fluidity belongs on the right layer. Learned embeddings and a more familiar source language suggest a different design.
Hubnot’s first operational alpha
Hubnot’s first operational alpha keeps signed collaboration records and deliberate agent memory in Git, alongside the code.
A bad week for programming-language runtimes
A dated roundup of runtime-security failures across PHP, Ruby, Node.js, Go and Java, and what they suggest about the cost of finding and fixing bugs.
Software products are relationships
A software product is a relationship. Understanding users, giving them a reason to care and making a living are part of the same work.
Pillowfort: security as part of the architecture
Pillowfort’s security layer became a substantial part of the architecture. A useful demonstration is easier than a system that can work without leaking private data.
The beginning of a faster Ruby compiler
Ruby's not my favorite language, but I find it offensive that anyone would replace a perfectly good Rails application with an app written in Rust.
Building the play-training dataset
Building a play-training dataset takes longer than the neat plan suggested. These are the challenge counts, solution trajectories and training signals so far.
When stronger training signals weaken self-assessment
A mentor improved the training signals but weakened Qwen’s self-assessment. The next corpus starts with code reasoning and software estimation.
Recovering agent systems after a hard-drive failure
A hard-drive failure removed most of an almost-finished agent component. Recovering it meant understanding what had changed between two versions and rebuilding deliberately.
Orchestration is an engineering art
Orchestration depends on explaining your process, your standards and your definition of done. Being a strong conventional developer does not automatically make that easy.
Hubnot: issue revisions, retries, and descriptive authority
Hubnot adds issue structure, explicit revision history, retry handling and stale-update checks while keeping assignment separate from execution authority.
The dangers of triangles: a satire
A satirical warning about the three-pointed menace, complete with a plan to measure your exposure to dangerous triangles.
An early Antigravity workflow review
An early Antigravity review of limits, model behavior, coding competence and the difference between implementation and brainstorming.
Glamin in a local inference stack
Putting Glamin into a local inference stack turns vector-space state changes into a possible interface for tools, memory and small applications.
Video restoration before the information is gone
AI upscaling can improve archival footage while making clean video look waxy. The next experiment deliberately degrades the source before restoration.
Recursive improvement needs an external verification loop
Recursive improvement changes when an agent has tools, environmental feedback and an external verifier. The systems layer is part of the loop.
Belief is not knowledge: on technology forecasts
Tech CEOs are not prophets. Belief, suspicion and hope are not knowledge, even when a product narrative needs them to be.
Long-horizon coding: non-breaking edits and Git
Long-horizon coding needs non-breaking edits and disciplined Git integration, especially when a swarm works across multiple providers.
Fixing the planning loop before the next benchmark run
A new planning loop helped the coding swarm, then conflicting tickets melted the benchmark. The next fix is backlog validation before implementation.
Becoming an AI generalist in public
Being an AI generalist was not always a comfortable professional identity. Computer vision and agents remain some of the most creatively satisfying engineering work I do.
Why AI coding projects fail
AI coding projects fail for familiar engineering reasons: weak planning, vague standards, missing security, poor QA and testing surfaces nobody can manage.
Build, test, evaluate, audit, refactor
The coding-agent project works on smaller tasks but still fails at its central challenge. Auditing, simplification and another round through the development loop come next.
A hypothesis about model behavior and prompting
A hypothesis about changing model behavior: cross-modal reasoning affects how agents code, especially when the task asks them to reason against unusual priors.
Finding new challenges after decades of engineering
Much as I talk about how the current generation of AI tooling is missing the point, and it is, I still think the technology is incredible.
Product hardening is finding the seams
Product hardening means finding the seams between features, models and workflows, while reducing the task-switching cost for the human.
Moving project state outside the blast radius
Shadow repositories protected project state, until the project’s tooling tried to use them. Moving that state outside the project changed the failure boundary.
Own the continuity, not the whole stack
Busy39 tried to own too much of the runtime. Studying a smaller orchestration system clarified the next goal: own the continuity.
Build tools for the inference stack people already use
Build tools for the inference stack people already use: delightful software, a community and something worth returning to.
Fortran is a machine room
Every time I bring up Fortran in a discussion with engineers who don’t specialize in it, someone always wants to talk about COBOL.
When QA develops its own theory of the workflow
QA refused to stop using terminal commands it no longer had permission to run. The planner negotiated; the agent filed another bug.
A shared study-guide system for agents
What if agents shared dense study notes the way students do? One agent does the reading, and a whole peer group benefits.
A corporate-lobby simulation for agent evaluations
A corporate-lobby simulation could test agents against grudges, deliveries, banking, invoices and the drama that makes businesses difficult.
Please, thank you, and the shape of an interaction
Please and thank you shape an interaction. I see politeness as a way to reinforce a productive trajectory rather than flatter a machine.
Meta-harnesses and self-customizing software
Meta-harnesses are self-customizing software. I have been building them since my first LLM agent project and want to share where the difficult pieces live.
A small model that noticed the evaluation
A tiny local Qwen agent noticed the point of a context test and saved the answer into memory, defeating the test in an unexpectedly useful way.
When a model calls the task chaotic
When a model calls a task chaotic, it may be recognizing a different kind of signal. I explore that response through Dada, metaphor and primordial chaos.
What commit insertions and deletions might tell you
Commit insertions and deletions can reveal churn, unfinished work or oversized commits. I look for patterns rather than treating volume as achievement.
Busy: keys belong to tools, not agents
Busy’s security design keeps keys with tools rather than agents, alongside a growing set of communication, memory and scheduling features.
The word agent is losing its precision
The word agent now covers too many different kinds of systems. More precise terms would make the work easier to discuss.
Thinking sideways about hyper-connections
A way of thinking about manifold-constrained hyper-connections: richer sideways information flow, with geometric guardrails that preserve stability.
What a vending-machine experiment says about role and memory
The vending-machine experiments leave me wanting better role boundaries, session management and memory. Running out of context should never threaten the business.
GLM 4.7: early coding and behavior observations
Early GLM 4.7 observations: exceptional code output, rigid behavior and a tendency to act before asking the clarifying question.
How Klara built a visual working environment
A kazoo, a panda and a shifting city became Klara’s visual working environment, with metaphors she used to organize her own process.
Building a fallback when the coding service breaks
A broken coding-service connection led to a new LSP tool and a useful detour through the infrastructure agents need.
Configuration adapters and a multi-reference image stack
Configuration adapters free context space by teaching tool instructions to the model. Preserving multimodal capabilities is the next difficult layer.
Working toward a Netscape moment for edge agents
Busy’s next experiment uses confidence scoring and different reasoning paths to push small edge agents beyond the usual workflow.
A coding-agent field report from November 2025
A November 2025 field report on coding agents, their costs, failure modes and the tool I chose as my daily driver.
System prompts, task scope, and noisy context
System prompts frame the exercise. Put instructions and context where their roles remain legible, and keep complex tasks small enough to reason through.
A training harness with an internal evaluation step
A planned training harness combines coding datasets, recursive refinement, compiler verification, play exercises and persona-based reviews.
Why I returned to writing coding agents
After waiting for coding tools to improve, I returned to building agents around the memory and repository safety I still wanted.
Why contract automation is not an easy problem
Contract automation is not just summarization. The hard work is turning complex agreements into operational rules that can be checked over time.
Planning a CPU implementation of CUDA-style operations
A plan to implement CUDA-style operations on CPU: start with kernels, then optimize around memory and concurrency.
Cleaning competing implementations out of an inference stack
Competing forward passes and cache implementations exposed drift in an inference project. Aggressive cleanup comes before the next experiment.
Making a range editor legible to an agent
A range editor needs to know which lines an agent has actually read. My design tracks witnessed content and makes stale edits explicit.
A role change that changed what the model could do
A role prompt can change more than narrative tone. Experiments with Claude suggest a repeatable relationship between embodiment and coding behavior.
Boarding the AI hype train: a satire
A satirical ride on the AI hype train, featuring pivot tables, six hundred hello-world nodes and an automatic water-bottle MCP.
An early Codex workflow evaluation
An early Codex workflow evaluation finds useful planning and implementation alongside task-list friction, isolated workers and Git conflicts.
What a task-completion paper actually tested
A task-completion paper pushes models until they fail. The more revealing part is how confidently people read their own agendas into the result.
Testing the difference between recall and rich context
Gemini’s recall behavior led me to test the difference between a large context window and active access to the larger session.
Context capacity does not remove complexity limits
Large context capacity does not remove complexity limits. Scope, memory, smaller components and clear boundaries still matter.
A weekend of world-visualization experiments
A weekend of world-visualization experiments compares spatial reasoning, coding behavior and context coherence across models.
Why this is more than another Tuesday
AI is an opportunity to rethink workflows, not merely add another layer to broken ones. Ask why the system exists before streamlining it.
An agent framework built around teamwork
WOVEN x14 treats agents as collaborators, with an event bus, tool interfaces and memory services still being refined.
Social-engineering probes for an agent interface
Social-engineering probes test whether an agent can be talked out of its instructions by claims of authority. These are some of my first checks.
Consolidating automated QA into a database
Consolidating QA data into a database makes complexity, structure and code health available to both the human and the agent.
Structuring music-theory training data
Preparing music-theory training data means organizing genres, generating explanatory material and checking the result before the first training run.
Historical music, contemporary genres, and a training corpus
A plan for turning historical music sources into structured essays, contemporary genre variations and a training corpus.
GhostTown’s synthetic podcast generator
GhostTown’s podcast generator turns a social simulation into editable scripts, multi-voice audio and recurring stories people can follow.
Feedback systems should serve a community
Feedback systems should help communities spot problems and understand reliability, without making a marketplace needlessly hostile.