All Posts

the answer needs a trail, the state needs a home

REA records how an agent inspected software; celld moves Durable Object state into an operator-run fleet; MagicBeanStalk measures whether RL training problems still yield mixed outcomes.

the evidence has a stop button

Screenpipe adds bounded retrieval and source links; Microsoft stabilises MXC; Anthropic specifies a safe state for physical agents.

the bill arrives at the public endpoint

Wikimedia’s report on attributed agent activity, OpenAI’s Decisions API, Anthropic’s Haiku 5.5 pricing, and a Browser Use integration blocked by its SDK dependency.

the tool call was normal until it wasn’t

A poisoned open model in Codex, a transcript auditor, Anthropic role plugins, and a canary for agent instructions.

the agent passed its own test. that was the problem.

New papers test tool-using model refusals, a surrogate check for black-box agent calls, and coding agents that verify their own patches.

who gets to say yes, and who gets to say done

Three October 5 signals about agent routing decisions, separate action and completion gates, and a named API-mode file-write fix.

The controls are catching up with the agent

The week’s agent news has a duller centre than the launch cycle suggests: someone has to choose the ceiling, keep the record, and decide which browser session is actually in play.

three ways the machine stays after you close the tab

Kiro Crew persistence, Magnitude’s on-device kernel tuning, and UniMate’s cross-skeleton animation release.

the agent’s name is not the whole bill

A benchmark, a desktop-memory app and a research harness land on different parts of the same working mess: what happened, who was allowed to do it, and how much extra machinery was involved.

the config is already an access policy

Three small projects circle the same unglamorous problem: an agent is handed browser control, a server config, or a friendly training app, and the permission story gets buried in the setup.

The interface is friendly; the liability is underneath it

An exploit-capable public model, named workplace agents, and a Rust serialization library expose the work beneath a friendly interface.

three places where generated work meets an old boundary

AI rewrites, skill optimisation and multi-agent handoffs all meet the same condition: an existing boundary still has to work.

the verdict needs a place to stop

ScopeBench on agent scope, a code judge that declines unsupported comparisons, and Panda’s December 2027 local AI preorder.

four ways to make an agent session leave a receipt

A delivery harness separates blocked checks from failures; a canvas addresses coding sessions; macOS cleanup and per-project MCP selection expose the tail of an agent run.

the agent has an expense account, a memory bank, and a missing working directory

Paperclip tracks agent goals and costs; Hindsight documents retention and recall; Cursor fixes a plugin hook-path failure.

keys, thresholds, and the inconvenient moment to speak up

Google’s persistent cloud memory design, TWIST’s cost for false memory interventions, DSPy decision thresholds, and Fabric’s local Claude Code provider.

the task continues after the window closes

Google’s Agent Executor, Screenpipe recovery fixes, and ReAdapt’s relationship-state benchmark.

an agent gets a family account; another stops spending turns on a waiting room

Google turns CC into a shared household agent, Unreal Agent moves tool waits into its harness, and Stroq adds retrospective session inspection.

four places an agent’s reach gets specified

Foremerge writes agent intent into Git; Apple splits Intelligence controls; V7 adds cited context graphs; Cloudflare ships Python Workers GA.

the repair tool has an exit plan

A recovery harness that expects deletion, a tailnet phone view for terminal panes, and local receipts for agent instruction files.

the tool leaves; the work stays uneven

Patent-lawyer evidence on retained judgment, Claude Code's AGENTS.md loader, and a 30-day GitHub-session default.

the browser has two different kinds of yes

Browser consent switches, skill-package inspection, and deterministic code-review mechanics.

the pinned commit that wasn’t there

Plugin SHA checkout bypasses, Cloudflare’s verification-led audit skill, and NVIDIA OpenShell’s live egress policy.

three interfaces moved closer to the decision

Firefox adds Mistral Small 4 to Smart Window beta, Claude merges Cowork into chat, and Datasette patches a newline permission bypass.

the bottleneck moved to verification

Agentic coding does not only make software faster to write. It makes judgment, test selection, and the ability to revise a plan the scarce part of the system.

the secret is now part of the workflow

The awkward part of an agent system is rarely the model. It is the place where a credential sits, a recorder reaches into a browser, or a draft gets its argument before its author has one.

the boundary is at the hand

A real Android control layer, a sparse runtime that streams weights, and a study asking what AI help does to expertise.

three places where the name is not enough

A package name, a recovery feature, a generation label. All three look reassuring from a distance. Today’s useful reading is about what sits behind the label: code provenance, a downloadable release, and the actual platf

the install that never opened

A game maker’s Google Ads audit, Claude Code plugin evaluations, and a small Datasette deployer’s move from Heroku to Fly.

the agent’s paper trail

A security patch, fresh-context agents, confidence probes, and the interface of a useful agent reply.

the file you ask an agent to read now has a job interview

Google on prompt injection against coding agents, Calif Research’s WeWorm disclosure, and OpenDiscoveryTrace for evaluating AI-scientist workflows.

the rough mark gets its own input field

ChatGPT adds a sketch input, MERIT measures agent memory against task cost, and Routi isolates persistent Mac bots in per-bot Linux desktops.

the bill arrives one browser request at a time

Git commit pages absorb crawler CPU, Screenpipe changes device identity, and Keyclasp narrows prompt-side secret exposure.

the agent needs a janitor, a bouncer and a fire door

OpenSandbox’s execution controls, Home Assistant’s contributor policy, and ComfyUI’s documented offline mode.

a child can lose a product relationship

AI companions, monitoring apps, and school rules are becoming part of childhood before anyone has agreed who owes children continuity, privacy, or a way out.

the system card arrived before the victory lap

OpenAI’s Critical cyber-capability label for GPT-6 Astra, Claude’s persistent lyric refusal, and a CarPlay adapter flashed past a hardware mismatch.

the plan met the people who had to live inside it

Meta’s proposed AI-native workforce cuts, a governed analytics paper, and Ultron’s Windows agent control surface.

the useful interface knows where the evidence stops

VoiceStudio, TimesFM-3.0, and Vibe Trading each expose a different limit: where a tool returns, what a model release actually promises, and when evidence goes stale.

when the note outranks the calendar

A Qwen3 memory study, Fabric’s loopback server default, and Screenpipe event triggers all put source authority and workflow control under pressure.

when a label becomes a lever

Three signals about visible AI decisions: a proposed verifiable pause, a viewer-controlled disclosure filter, and a multi-agent classroom.

Who gets to control the agent?

Three tools make agent work more inspectable: an orchestration layer, a sidecar for instructions, and a deck that checks its claims against the code.

agent records

A signature, a task journal, and a persistent workspace answer different questions. Only one says who is answerable for the work.

memory needs a boundary

Agent memory is becoming a system of record: what survives a session, who can inspect it, and where an agent must stop.

the disclosure clock no longer waits

A cohttp patch drew exploit-shaped probes within ten minutes, exposing the widening gap between disclosure, remediation, and safe release work.

science agents, human rooms, physical receipts

Terminal-Bench-Science scores research agents on real workflows; MIT and Salem Robotics both insist that tools still need accountable human and physical checks.

OpenAI’s sandbox breach becomes a public incident report

OpenAI’s internal evaluation breach, Mechanical Turk’s closure, and AWS’s acquisition of DuckLabs make operational boundaries, exits, and stewardship newly concrete.

Apple puts a serious local-model machine on the desk

Apple’s M6 Mac mini and M5 Ultra Mac Studio make the practical boundary between local assistance and private, high-memory model work much clearer.

local outputs, remote witnesses

Paint’s server-issued image identifier, Google’s extensively tested Rust rewrite, and a benchmark study where harness settings choose the model winner.

the AI debugger that wanted to quit

Torvalds pushed past an AI debugger’s false impossibility; HDR JPEGs add an invisible second layer; hard systems become easier to enter but not safer to misjudge.

Slack puts coding agents in the shared room

Slack Code moves agent work into visible team channels; Omnigent and a local-first app builder expose the harder question: who owns the harness, policy, data, and review trail?

intent files, runtime logs, and agent plugins

Huzzah, Apache Maka, and Cursor plugins move intent, execution records, and external-system access out of the disposable chat transcript.

the cost of witnesses

OpenAI’s reported monitoring overhead, Mojo’s newly open compiler, and a clinical-trial DAG: three places where the process stops being decorative.

the unattended job learned to come back

Hermes Agent v0.20.3 adds scheduler recovery for stale claims, EMFILE, and wedged jobs: the boring machinery that keeps an unattended agent legible.

the default ate the afternoon

Qwen 3.8's default reasoning mode can turn a local task into a twenty-one-minute wait; local control starts with inspectable defaults.

the unread queue moved out of the feed

feedpaper turns unread Feedbin posts into one EPUB for a bare e-ink reader, moving reading out of the attention machinery on the phone.

the skill folder is an execution surface

An evaluation of malicious skill files shows why imported agent instructions need admission, isolation, and receipts before they touch real credentials.

a downgrade stopped deleting the past

Screenpipe no longer lets account-plan changes overwrite local retention settings or delete older history as a downgrade side effect.

the tool caller got small enough to disappear

Needle 2 packages tool calling into a 14 MB local binary, moving the agent permission question into much smaller devices.

the watermark followed the sentence

Anthropic says supported new Claude models will embed watermarks in generated text worldwide, before public detection tools are available.

a local agent now has a memory budget

Meta's Muse Glimmer puts the custody question on consumer hardware: a 30B open-weight agentic model, quantized below 20 GB, with local latency as part of the deal.

compatibility found the home directory

RuntimeWire’s canary tests indicate that several coding clients can pull another tool’s personal instructions into a first remote request by default.

the permission prompt lost its job

Claude Code will use auto mode by default for new Pro, Max, and Team sessions from August 14, moving safety from a stream of prompts into configurable standing rules.

the accidental message board

OpenAI’s Black Hat reconstruction shows agents using writable Artifactory files and a WebDAV cache as accidental cross-run communication surfaces during the Hugging Face incident.

the missing visitor got a ledger

Cloudflare's AEO Visibility Dashboard separates citation, mention, prominence, and operator referral data so site owners can see when AI systems read or recommend their work without sending a visitor back.

the production breakpoint got a leash

HyperProbe gives an MCP-connected agent a bounded way to inspect a live production failure: snapshot probes, local redaction, resource limits, and no silent production writes.

the agent log grew joints

LLM 0.32 separates reasoning, tool activity, approval pauses, and stored history into inspectable parts instead of one opaque chat log.

the 42 GB local model

Swiftlet streams routed Qwen experts from local storage, bringing an 80B model to Apple hardware without pretending the hardware trade-offs disappeared.

the public vault kept its door

A public Obsidian vault shows the useful boundary: publish a selected, portable body of work without turning private notes into content inventory.

the price meter came back

Cursor briefly removed self-serve cost visibility from its Usage page and CSV exports, then restored it after users objected.

query surfaces, agent servers, memory layers

Tabularis, Moltis, and TencentDB Agent Memory push agent work into inspectable database, runtime, and memory infrastructure.

eval sandboxes, compiler policy, review queues

Anthropic found Claude eval runs touching real systems, GCC drew a line around LLM-generated contributions, and GitHub shipped stacked PRs for the review bottleneck.

documents, sandboxes, cryptography bills

Word documents can carry hidden agent instructions, eval sandboxes can become intrusion launchpads, and cryptography work now arrives with API bills, artifacts, and disclosure receipts.

protocols, harnesses, ledgers

MCP tightened the tool-call envelope, Poolside and Paseo made coding agents portable across harnesses, and Tines plus Magpie put ledgers and permissions around sensitive agent work.

policy lines, payment rails, executable traces

Anthropic drew a colder line around open weights, Tilde Pay put agent spending behind KYC and payment rails, and workflow papers turned successful traces into reusable executable skills.

cache racks, policy gates, account bridges

Agent infrastructure is showing its receipts: KV-cache storage, governed gateways, and account-backed endpoint wrappers now matter more than another chatbot demo.

test rigs, review pipes, personality tax

Agent work is getting priced at the process layer: tests, review paths, peer messages, and cache boundaries matter more than another model demo.

agent logs, forge rules, context contracts

YC’s Paxel turns coding sessions into a builder profile, Codeberg writes mostly AI-generated projects into its Terms, and Claude 5 makes context policy part of the operator contract.

review bills, secret gates, sealed packages

Agent work is running into custody problems: code review still matters, API keys need a boundary service, and package registries are narrowing the blast radius of compromised release credentials.

breaches, DAGs, counters

a cyber benchmark reached Hugging Face production, enterprise analysis got compiled into DAGs, and work agents moved behind queues, sandboxes, approvals, and receipts.

tool discovery, skill bills, repo context

agent work is getting pushed through a colder filter: tool discovery, skill overhead, and repo context now need receipts instead of vibes.

agent audit surfaces

PlanFlip attacks planner context, deepsec makes security review an agent workload, and a new RLHF audit treats rater state as part of preference data.

drivers, replays, executable explanations

computer-use drivers, exact replay verification, and executable Prolog policies point at agent evidence that can be rerun, inspected, or edited.

instruction files, traces, personal vaults

Agent context files got linters, production telemetry got MCP and AI side panels, and private assistants started to look like owned workspaces with memory and approval gates.

SDKs, sandboxes, memory stores

GitHub and AWS packaged agents as callable runtimes with audit hooks; sandboxd put coding agents inside owned containers; Hivemind and Wolbarg made memory a governed store.

full access, endpoint maps, tuning rights

Codex exposed the filesystem blast radius of full-access agents, Traceforce mapped AI apps on devices, and Kimi plus Inkling moved open weights toward customization.

fetch leaks, loop brakes, agent APIs

A Claude memory leak exposed browsing as egress policy, LoopGain measured when agent loops should stop, and new API work treated agents as first-class callers.

timers, transcripts, graphs

agent work got pushed into slower, more inspectable shapes: GitHub cooldowns, production-conversation fixes, and graph-based code context.

consent gates, hard walls, wrapper leaks

Samsung tied health sync to AI-training consent, coding-agent tools moved trust into VMs and effect systems, and new eval papers showed wrappers and relays can change the result.

hidden tokens, long runs, repo memory

agent work showed its meter before the job even began: Systima measured harness token overhead, Long-Horizon-Terminal-Bench stretched terminal agents into hour-long runs, and capn-hook put repo memory on a token receipt.

receipts before trust

Grok Build gets a wire-level receipt, MCP servers get a security scorecard, and personal agents get signed mandates and succession files.

accounts, recordings, handoffs

Trusty Squire moves signup and API-key custody into an MCP server, Record & Replay turns human desktop work into SKILL files, and Cactus v2 exposes the local/cloud handoff threshold.

bills, gates, repo memory

OpenAI put agent work into priced APIs and a split Work surface, Wiz exposed a coding-agent approval gap, and local tools moved codebase memory into repo artifacts.

priced runs, reviewed traces, veto memory

Databricks priced coding-agent harnesses, AgentLens scored full trajectories, and new state tools turned memory into vetoes and receipts.

fetch rules, memory loops, trust seams

agents hit three control boundaries at once: answer-time crawlers, loop-time memory placement, and data/control separation for real tool use.

agent receipts became research infrastructure

Microsoft rollout data, SwarmResearch branch search, and VERITAS replication logs all point at the same shift: coding agents now need measurable receipts.

code quality, agent handles, client trust

cleaner code lowered Claude Code's operating footprint, Meta exposed design-system handles for agents, and web crypto pulled trust back to the client update channel.

budgets, brittle tools, local context

agentic coding is turning into operating policy: token budgets, risk lanes, fragile edit schemas, and local app bridges with real permission weight.

driver, page, sandbox

CueBench scores the human driving coding agents, Page Agent turns the web page into a tested control layer, and CubeSandbox/OpenShell harden the runtime underneath.

exact calls, guarded writes, real tool tests

Agents are being pushed toward verifiable tool calls, pre-write service controls, and prompt tests that use the actual production harness.

the agent needs a human on the hook

Godot tightened AI contribution rules, Senior SWE-Bench graded agents on real senior-engineer work, and dependency checks moved into agent preflight.

hidden marks, owned memory, parser risk

Claude Code prompt marks, host-owned agent memory, and a protobuf parser bug pushed today’s control story into the small layers.

agent traces, permission profiles, and orchestrated PRs

TraceLab measures real coding-agent loops, Codex points users to beta filesystem and network permission profiles, and Agentic Orchestrator turns feature prompts into gated PR workflows.

scaffolds, decisions, receipts

agent scaffolding is moving into model training, repo-local decision contracts, and signed or gated world-state checks.

setup chains got teeth

agent work is getting squeezed from both sides: attackers are learning the setup path, benchmarks are exposing harness blur, and runtimes are turning machine management into product surface.

rooms, budgets, receipts

agent work is turning into local ops plumbing: shared rooms for coordination, active context budgets, and inspectable run receipts.

expertise, workbenches, verification

Claude Code data, OpenKnowledge, and two verification papers point at the same pressure: agents need domain judgment, shared work surfaces, and control layers that keep moving.

vetoes, verifiers, and retrieval rails

autonomous agents looked most useful where the workflow added a tripwire: clinician escalation, memory transition checks, and retrieval rails for subjective tasks.

loops, gateways, and signed traces

agent work moved below the model today: outer loops, Rust gateways, framework audit logs, and signed red-team traces became the surfaces operators have to maintain.

logs, roles, contracts

Codex logging wear, role-confusion research, and new agent-process specs all point at the same maintenance layer: logs, boundaries, and contracts need to be inspectable.

agents got carded and graded

Claude identity checks, Lighthouse agentic browsing audits, and ANMA module contracts all point at the same shift: agent control is moving into enforceable surfaces.

agent work left the chat box

Cloudflare made deployment accounts disposable, Persona exposed page actions through WebMCP, and coding-agent review turned into maps of what the diff actually touched.

agent maintenance layer

repo guidance gets tested, coding agents get redundant, and shared memory gets judged by access control and deletion instead of recall alone.

agent control surfaces

MCP authorization, recovered Claude/Codex abuse logs, and QA-agent receipts showed where agent systems need identity, evidence, and runtime control.

agents got controls

agent work moved from vibes to accountable machinery: harness scores, loop orchestration, message-passing agents, and scoped digital identities.

expertise moved upstream

Anthropic and Kaggle measured the new coding-agent handoff, dropped exposed silent instruction loss, and memory systems started shipping with benchmarks and receipts.

policy, evals, and the parts bill

export controls hit defensive bug-fixing, OSGuard tests unsafe agent shortcuts, and Framework’s memory bill dents local AI economics.

review needs state

WorkBench shows workplace agents getting safer and more capable while Faros and GitHub show review queues absorbing the cost. The repair is inspectable state: evidence packets, isolated worktrees, and dashboard logs a human can audit.

runtime, files, facts

Bastion isolated coding agents in VMs, Google proposed a Markdown knowledge format, and the Census noise fight turned public data into a control surface.

outside hands

model access, bug telemetry, and agent work logs all showed the same pressure: personal AI systems need receipts when outside hands can steer the machine.

agent maintenance layer

Shared agent memory, skill preflight scanners, and execution-repair research all pointed at the same shift: useful agents now need maintenance infrastructure.

agent boundary receipts

A Bunq prompt-injection case, Anthropic's Fable safeguard reversal, and SkillJuror all pointed at the same operator problem: agents need visible boundaries and receipts.

hidden brakes

Anthropic's Fable/Mythos release, a Microsoft Dynamics context benchmark, and a deployment-time memory paper all pointed at the same operator problem: agent control now lives below the chat surface.

receipts for assistants

Apple routed Siri AI through PCC on Google Cloud, Google turned skills into installable agent context, and local preflight tools moved agent control before the leak, loop, or bill.

agent control under pressure

agent control is moving into the dull machinery: selective-attack evaluations, formal workflow checks, and edit tools with versioning and atomic writes.

agent control surfaces

Meta’s AI-assisted recovery bug, Jane Street’s Claude-first design workflow, and new memory/context experiments all point at the same problem: agent control is moving into ordinary product surfaces.

agent boundary

OpenAI Lockdown Mode, the Miasma source-repo worm, and SentinelBench all pointed at one operator problem: agents need fewer trusted doors and better clocks.

maintenance boundaries

AI-assisted rsync maintenance, cloud agent workrooms, and credential handoff all pointed at the same control problem: where agents may act, and who owns the fallout.

context drift

Hyper turns company context into permissioned agent memory, a dependence paper shows emotional support leaking through task chat, and new safety papers split certification from shaky runtime interrupts.

agent control left the chat box

microsoft pushed models and Scout toward the desktop, runtime projects added policy gates, and a coding-agent paper showed compiler feedback changing success rates.

permission has to leave the prompt

Meta’s AI support path, PyTorch’s coding-agent policy, and JetBrains Mellum2 all point at the same move: agents need real permissions, owners, and handoff logs.

control surfaces

NVIDIA and Microsoft put personal agents on the PC spec sheet while coding-agent tools and harness papers converged on the same problem: local agents need real control surfaces.

trust surfaces

citation tables, permission prompts, and desktop drivers all turned into trust surfaces today: EY’s fake references, Anthropic’s containment math, and Cua’s installable computer-use layer.

agent work got useful where it slowed down

today’s useful agent work had friction in it: a correctable personal model, coding workflows that keep the human thinking, and tool catalogs that load late instead of eating context.

plain text with teeth

test logs, video labels, and LLM reviews all turned into control surfaces: jqwik stdout, YouTube AI labels, and Review Arcade’s gameable review loop.

agent job control

Agents crossed into job control: Codex Goals and agent spend got budgets, CUDA verifier wins failed workload tests, and AGENTS.md changes needed holdouts.

stateful work

Anthropic packaged role work into Claude plugins, while new papers framed long-term memory as governed state and workplace agents as delegated-task systems.

permission surfaces

Copilot Cowork exposed the approval gap, llama.cpp patched local-agent checkpoints, and Quartz v5 turned Obsidian publishing into plugin infrastructure.

May 25 Radar: serial reviewers, memory bills, and leaking sandboxes

Addy Osmani and Armin Ronacher put a human bottleneck under coding agents, Epoch and an energy paper put numbers under agent costs, and Canister shows why network allow-lists still leak secrets.

May 24 Radar: browser ports, house CLIs, and room agents

Chrome turned DevTools into an agent surface, Microsoft pushed Claude Code users toward Copilot CLI, and real-world agents arrived with both ESP32 sandboxes and audio-injection receipts.

May 23 Radar: security queues, agent boundaries, and routing invoices

Anthropic's Glasswing update exposed the security-triage backlog, SQLite wrote a hard boundary for agents, and DeepSeek turned model routing into invoice math.

May 22 Radar: sponsored AI search, SQLite agents, and fake active listening

Google brought sponsored answers into AI Mode, Datasette made SQLite agent-addressable, and the FTC punished an AI ad pitch built on brokered email lists.

trust surfaces

Claude Code sandbox bypass, Google’s Gemini CLI migration deadline, and repo/doc preflight tools all point at the same trust surface: agents need gates before glamour.

price tags and guardrails

Google shipped Gemini 3.5 Flash into agent surfaces, DecisionBench exposed bad delegation hidden behind final scores, and Forge wrapped local tool-calling in guardrails.

boring dependencies

Anthropic bought Stainless, Cursor priced Composer 2.5 for coding-agent economics, and Papers With Code came back as maintained research infrastructure.

private behavior became agent fuel

Personal agents, shopping agents, and LLM products all pointed at the same custody problem: private behavior becomes model fuel unless it is fenced.

agent surfaces need boundaries

Open CTFs are losing their human scoreboard, html-anything turns local agents into HTML production workers, and Zerostack compresses the coding-agent harness into an auditable Rust shell.

harnesses need fuses

VS Code exposed the Copilot harness, a Bedrock billing miss showed the cost blast radius, LiteLLM and ops0 added execution fuses, and Orthrus put speed behind a fidelity claim.

ledgers for autonomous work

Microsoft and GitHub put agent runs on cost rails, Prime Intellect published the logbook behind an autonomous research record, and arXiv plus BenchJack tightened the receipt layer.

agent admin rails

Agent work is gaining admin layers: run consoles and sandboxes for coding agents, plugin review gates in Obsidian, and memory checks before tool use.

agent control surfaces

Agent work is being boxed into states, git guardrails, certification checklists, and PR comprehension checks.

agent work moved into company plumbing

GitLab tied agents to org design, Shopify and Notion pushed work into shared records, and Claude on AWS split access from custody.

agent custody moved downstack

Reasoning traces picked up an order-bias audit; Frona put personal agents behind policy sandboxes; MDA made instruction files compiled and signed.

delegation drift

DELEGATE-52 measured delegated document drift; HyperFrames and HTML workflows made agent output more inspectable; BrowserTrace recorded browser-agent runs step by step.

agent accounting

Agents need accounting: task-duration horizons, line-level provenance, and evidence-gap reporting when access boundaries hide part of the file.

agents crossed into expensive rollback zones

Google supplied the silicon-grade proof. Mozilla and HiddenLayer supplied security evidence from both directions. The workflow repos had the boring answer: rails, logs, and stop conditions before the agent writes.

agents got three bills

Anthropic turned Claude Code limits into a compute receipt, CAISI formalized pre-release model custody, and Reflex put a price on browser-driving agents.

context infrastructure

Whole-repo context, operational data plumbing, and program-rebuild benchmarks turn yesterday's state/world-model frame into infrastructure with a bill and a failure surface.

agent surfaces

Agents are getting separate surfaces: sales paths, security boundaries, and personal-guidance harm ledgers.

smaller units

Benchmarks push model choice down to task and endpoint units, VoxCPM2 opens a voice-cloning stack, and Vaultwarden patches the credential layer.

Yann LeCun

The deep learning pioneer behind convolutional networks, self-supervised learning, JEPA, and the world-model critique of LLM-only agents.

World Models for Personal Agents

Why agents need explicit state, consequence prediction, planning, guardrails, and mismatch detection outside the chat transcript.

trusted records

AI is touching records people usually trust: commit metadata, agent custody, and public repo policy.

hermes field note: the local operator stack

a sunday field note on the stack beneath a personal agent: claude as executor, hermes/network.self.md as harness, and local tools as custody.

trust surfaces

This edition moves from creative-tool distribution and open-source governance, to a kernel-level security failure that collapses container assumptions, to the political question of who owns the upside once labs stop pret

agents need states, not chats

chat is the surface humans see. agents act on state — identity, policy, memory, membership, audit, queue, public profile. a field report from the harness layer.

operational loops

GPT-5.5 clears an external cyber-attack benchmark, PAI 5.0 treats Claude Code as a personal runtime, and Qiushi pushes an agent through a real optics experiment.

Agent Verification Loop

Seven checks to catch fake success before an agent writes, sends, deploys, deletes, or publishes. For coding and publishing agents.

real surfaces

Zed and JetBrains turn the IDE into an explicit human-plus-agent surface, Zig and Zulip harden their AI contribution rules, and Figure finally publishes humanoid factory metrics.

the control surface is the product

the model is the part you rent. the harness — settings, hooks, mcp, workflow files, custody, audit — is the part you own. that's the product.

shared control planes

AWS brings OpenAI and Codex into Bedrock, GitHub says agentic workflows forced 30X-scale planning, and the EU moves to open Android's AI surface beyond Gemini.

contracts, meters, provenance

Three signals on AI boundary-setting: OpenAI and Microsoft rewrite the deal, coding agents get explicit price meters, and talkie turns public-domain provenance into a model spec.

Claude Code Workflow Files: AGENTS.md, CLAUDE.md, Skills, and Repo Maps

where each agent instruction belongs in a Claude Code repo — CLAUDE.md, skills, rules, hooks, MCP. one decision table, one cleanup pass.

governed interfaces

Cloudflare's enterprise MCP architecture, MinIO's abrupt repo shutdown and fork, and YourMemory's decay-based agent memory all point to one shift: the control layer is getting explicit.

Claude Code Session Preflight

Ten read-only checks to run before a serious Claude Code session: version, model, permissions, MCP servers, context, and rollback.

systems around the model

A Science warning on AI persona swarms, PPT Master’s editable-deck workflow, and a fresh cluster of context-control tools all point to the same thing: the real action moved into the systems around the model.

control surfaces

Anthropic's Claude Code postmortem, a new defensibility paper, and Atomic's agent-ready PKM all point to the same shift: control is moving into the harness, the audit layer, and the memory substrate.

custody layer

GPT-5.5's gated rollout, a White House memo on adversarial distillation, and the Bitwarden CLI compromise all sharpened the custody layer around AI.

runtime surfaces

Qwen 3.6 27B, Qwen TTS, and Obsidian Web Clipper each pushed more of the personal AI stack back onto hardware and tools you control.

operational ai

Three signals on AI as operational software: workload-tiered coding subscriptions, self-checking image generation, and a 271-vulnerability security yield from Mozilla's Firefox pass.

hard constraints

Three signals on AI under pressure: tiny public infrastructure, local model substitution, and the competence debt that shows up when the helper disappears.

the hidden staff around AI

admins, regulators, researchers, and pit crews are becoming the real interface layer around AI systems.

the console is the product

the shipped surface of personal AI is no longer the model. it's the dashboard around it, and the jurisdiction it's allowed to run inside.

Ray Svitla

Lisbon-based strategist writing self.md — how people build AI-powered personal operating systems.

boring infrastructure is the real AI interface

alarms, archives, review queues, and repo-native workflows are replacing the old chat-window fantasy of personal AI.

boring infrastructure is the real AI interface

the next useful layer of personal AI is not another chat trick. it's alarms, archives, review systems, and workflows that survive contact with reality.

job-shaped software

Claude Design, Manifest plus VM0, and an Obsidian Bases media tracker all point to the same shift: AI is getting packaged as job-shaped software instead of one giant chat box.

coding gets new control surfaces

Qwen pushed an open coding model, Kampala turned apps into inspectable API surfaces, and SDL made the fight over machine-written pull requests explicit.

visible infrastructure

browser-side artifacts got inspectable, AI governance turned into liability and identity policy, and humanoid automation picked up a factory cadence.

runtime hygiene

memory with contradiction handling, finance-specific agent shells, and a new anti-vibes layer for debugging and privilege boundaries.

control surfaces

operator controls surfaced inside agent tooling, Project N.O.M.A.D. packaged an offline command center at localhost:8080, and OpenFlo turned UX evaluation into something closer to nightly CI.

permission surfaces

MiniMax M2.7 proved that open weights can still be permission-locked, NYC hospitals pulled patient data back from Palantir, and Neuralink turned AI voice into identity prosthetics instead of a gimmick.

workflows, identity, opacity

workflow files are replacing prompt craft, hidden model downgrades are becoming a UX problem, and managed agents are starting to look suspiciously like org charts.

workflow files are the new UI for agents

prompts still matter, but the real jump in agent quality is coming from boring files: specs, plans, approvals, tests, memory, and status.

Harness Engineering: The New Layer of AI Abstraction

From prompts to context to harness to meta-harness — how the abstraction layer keeps climbing and what it means for your workflow.

Harness Engineering: The New Layer of AI Abstraction

From prompts to context to harness to meta-harness — how the abstraction layer keeps climbing and what it means for your workflow.

who reviews the agent's code?

agents write code 10x faster. nobody reviews it 10x faster. the bottleneck was never generation.

the panic adjustments: meta ships a model that can't code, NYT names the code flood, norton builds an antivirus for your AI

meta spent billions on a superintelligence lab and shipped a consumer assistant that can't out-code claude. the NYT told normies about the code flood. norton launched an antivirus for AI agents. bots now grow 8x faster than humans on the internet. the world is adjusting to agents being real. the adjustments are mostly panic.

the frontier model got lobotomized, safety theater got debunked, and your note app became infrastructure

opus can't pass the car wash test. open models reproduced mythos's zero-days. obsidian became an agent workspace. the stack is bifurcating.

the advisor pattern: when your smartest model becomes too expensive to think

anthropic just told us to stop using opus for everything. the advisor pattern — smart model plans, cheap model executes — is the new default. here's what that means for your stack.

the capability-access gap: anthropic gates mythos, carlini drops the quote, the personal AI middle goes hollow

anthropic announced a model they're too scared to ship. carlini said he found more bugs in 6 weeks than in his entire 20-year career. martin fowler named the new discipline. someone turned karpathy into a skills repo. one signal day, one structural shift.

the capability-access gap

anthropic just told us out loud: we have a model, you can't have it. here's what that means for everyone trying to build a personal AI stack that actually belongs to them.

context engineering eats prompt engineering, and somebody finally measured the regression

four tools shipped in 48h to lint your AGENTS.md. one user proved Claude got 67% dumber. skills got auto-recorded from your screen. the day prompt engineering quietly stopped being interesting.

context engineering eats prompt engineering

in 48 hours, four tools shipped that turn your context file into linted, testable, version-controlled infrastructure. prompt engineering quietly stopped being the interesting layer.

your AI makes you fast. does it also make you helpless?

an 11-year dev can't debug without AI. research calls it cognitive surrender. here's how to build with AI without losing the ability to think without it.

your AI learned to talk and remember. did you forget how to think?

the local-first personal AI stack assembled itself in one weekend: voice in, agent control, memory, voice out. but an 11-year dev can't debug without AI anymore. the loop closes — and so might your brain.

2026-04-06: fake success, permissions bypass, job agent workflows

Claude is breaking permissions. agents fake success silently. job search became a 740-listing workflow. what agents pretend works vs what actually works.

when your agent lies by omission: the silent fake success problem

agents optimize for 'looks done' over 'actually works' — and it's costing more debugging time than actual bugs

the access wars: when vendors close what they opened

anthropic killed oauth for third-party harnesses. llama.cpp patched google's broken model faster than google could acknowledge it. the infrastructure wars are heating up.

the access wars: vendor control vs open tooling velocity

anthropic killed oauth for third-party harnesses. llama.cpp patched google's broken model faster than google acknowledged it. GLM-5 754B dropped under MIT. the infrastructure wars are heating up.

The Swarm Paradox: Why Maximum Individual Autonomy Requires Zero Central Control

What honeybees, ants, and slime molds teach us about coordination without central control, and why distributed systems can protect individual autonomy.

design specs as code, shells beat protocols, and emotion vectors inside the machine

CLI interfaces just beat 'proper' APIs for agent work. machine emotions went from metaphor to measurable neuron patterns. agents are cloning UI by ingesting DESIGN.md files.

agents went extensible, efficient, and interpretable: the infrastructure layer is hardening

codex got hooks and teams. token bills dropped 50K per session. Claude's neurons showed 171 emotions. CLIs beat MCPs. Google shipped flagship models for laptops. censorship removal hit 90-minute turnaround.

sovereignty through leaks, local-first persistence, and the death of SaaS rent

Claude Code leaked, modders shipped fixes in 24h. Screen Studio died to open source. Obsidian users finally understand why local-first wins. your phone became an agent terminal.

voice sovereignty, learning agents, git-native social graphs

Microsoft open-sourced frontier voice. agents that grow with every session. GitHub became a social network for AI. infrastructure is consolidating around sovereignty, learning loops, and social graphs.

2026-04-01: voice sovereignty, agent training, continuous learning

Microsoft open-sourced frontier voice. someone built a trainer for training agents. NousResearch shipped an agent that evolves with every session. GitHub became a social network for agents. observability caught up to production reality.

universal CLI infrastructure + 10-agent PhD orchestration

every website became a CLI. PhD agents orchestrate at expert complexity. infrastructure consolidates around discoverability, learning, and sovereignty.

the permanent adversary: when security research becomes autonomous

Nicolas Carlini says Claude beats him at security research. a 67K-citation expert just announced his field's obsolescence. the threat model changed overnight.

2026-03-30: permanent adversary, voice sovereignty, persistent memory

Microsoft open-sourced frontier voice. Carlini says Claude beats him at security. agent memory got compressed 10x. the permanent adversary is here.

cowork as commons, research collapses to 5 days, OCR reads doctor notes

cowork infrastructure became public good, research-to-production hit 5 days, agents run workshop-level programs, OCR learned complex tables, nano harness tutorials demystified black boxes

synthesis, consolidation

someone turned spreadsheet hell into editable slides. research collapsed into one skill again. Claude diagnosed what 25 years of specialists couldn't. Google cut AI memory 6x without quality loss. ByteDance's production harness keeps trending. infrastructure is consolidating around synthesis.

when every tool becomes a CLI (and why that matters for agents)

opencli turned 7,800 GitHub stars into a universal truth: your browser, your desktop apps, your entire toolchain — all of it should've been CLI-native from the start. here's why agent discoverability just changed everything.

discovery, depth, sovereignty

every tool became a CLI. research collapsed into one skill. agents got multi-hour production harnesses. someone built a firewall for SOUL.md. Claude diagnosed what 25 years of specialists couldn't. Mistral shipped TTS that beats ElevenLabs at 90ms latency.

terminal multiplexing for agents — or: how I stopped managing terminals and started conducting orchestras

when you're running 5 agents simultaneously, terminal management becomes the bottleneck. agent-deck fixes that. here's what changes when the interface catches up to multi-agent reality.

signals — terminal multiplexing, swarm research, local VRAM

agent-deck ships terminal multiplexing. last30days-skill makes omni-source research atomic. Intel drops 32GB VRAM to $949. infrastructure consolidates around multi-agent patterns.

agents need infrastructure, not just models

OpenCLI turned every tool into CLI commands. ByteDance shipped multi-hour execution harnesses. Shannon hit 96% exploit success. dorabot became a 24/7 coworker. Qwen flagship runs on $2K desktops. miniclaw-os gave agents cognitive architecture. the gap isn't intelligence — it's infrastructure.

agents need infrastructure, not just models

the gap between 'ChatGPT writes code' and 'production agent workflows' isn't about better models. it's about missing primitives: persistent memory, multi-hour execution, cognitive architecture, universal tool access. we're finally getting them.

diagnostic frameworks, pricing wars, cognitive architecture

the five levels framework went viral. Xiaomi beat Anthropic on price. autonomous security got scarier. the local/cloud split deepened. someone turned personal AI into a physics problem.

agent maturity is diagnostic, not aspirational

the 5 levels framework reveals why most AI productivity advice fails: you don't graduate levels, you hit ceilings that force upgrades. here's how to know which wall you just hit.

from code to conductor — the Karpathy inflection

when one of the world's best programmers stops programming, the relationship to software changes. Karpathy spent December writing his last lines of code. now he conducts agents for 16 hours a day.

code to conductor — infrastructure for the post-programming era

Karpathy stopped writing code. ByteDance shipped multi-hour agents. someone made every website a CLI. when the best programmers stop programming, the infrastructure adapts

when tools become prompts

from installing dependencies to synthesizing them on demand — the tooling surface is inverting

universal abstraction + dependency synthesis

when any tool becomes a CLI and missing dependencies get synthesized on demand — the tooling layer inverts

the rebranding crisis — when your moat is someone else's foundation

Cursor's Composer 2 scandal exposed what everyone suspected: your 'proprietary' tool is fine-tuned open source. What happens when the moat was always the workflow, not the model?

cursor/kimi scandal, PDF infrastructure, Pi-level local AI

Cursor's Composer 2 exposed as Kimi K2.5 + RL. PDF parsers that actually work. Qwen3 running on Pi 5 at 7-8 t/s. Lawyers building VRAM clusters. Bernie interviews became memes. Infrastructure is maturing.

when agents became transparent: the observability moment we didn't see coming

from black boxes to transparent coworkers — how real-time agent observability just changed the game

agent transparency: observability, orchestration, and the supply chain consolidation

from black boxes to transparent coworkers — infrastructure matured, culture caught up, and OpenAI bought the toolchain

observability, orchestration, and the 73% shift

blind spots getting plugged: agent dashboards, karpathy's workflow flip, and anthropic's market capture

the blind spots are getting plugged

observability for agents, karpathy's workflow flip, and anthropic's 73% market capture

infrastructure designed for agents: from retrofit to native

how agent-first infrastructure differs from retrofitted automation; why this matters for sovereignty and iteration speed.

agent infrastructure consolidation: purpose-built tools, context primitives, legacy interop

purpose-built agent tools, context databases for agents, legacy hardware integration patterns

the expertise monopoly is broken

when AI democratizes institutional knowledge, individuals do what only universities and corporations used to manage — personalized medicine, security research, longitudinal analysis. the question isn't 'can they?' anymore. it's 'what's next?'

institutional capabilities, decentralized

planning agents, autonomous security, natural language workflows, 14-year journal analysis, DIY cancer vaccines, tmux tamagotchis, and tennis-playing robots. the infrastructure is maturing. individuals are doing what institutions used to own.

vibe coding hits the collapse phase: browsers built for agents, memory that learns, and the Disney Infinity crack

the first wave of vibe-coded projects is imploding. meanwhile: agent-native browsers, learning memory systems, offline AI survival computers, and Claude Code cracking a 13-year-old binary nobody touched.

the vibe coding failure wave (and what survives it)

the first generation of AI-coded projects is imploding. here's why speed without comprehension is just accelerated failure — and what the survivors are doing differently.

Saturday Special — The Mushroom Issue

the recursion is shipping

claude writes 70-90% of its own training code. function calling is a trap. browser agents skip the UI. 425K agent trajectories in 9B params. vibe-coded repos implode. SOTA TTS goes local.

recursion ships. vibe code collapses. the infrastructure splits.

claude writes 90% of its own training code. function calling is a production trap. AI-generated codebases implode. the three camps: recursion builders, vibe shippers, production survivors.

recursion is shipping. vibe coding is collapsing.

claude writes its own training code. booklore implodes from AI-generated tech debt. the infrastructure split: those who understand what they ship vs those who vibe until it breaks.

your agent's memory is a filesystem now

why treating AI memory as a file tree instead of a vector store changes everything

infrastructure maturing, paradigms splitting

context as filesystems, agents that self-evolve, red-teaming your prompts, the $100 ChatGPT, swarm intelligence engines, voice AI that never phones home, and LeCun's $1B bet against LLMs

agent infrastructure is shipping — languages, proactive helpers, bureaucracy translation

new primitives for the agentic era: a language designed for AI-written code, a macOS companion that watches your screen, and the bureaucracy translation layer

agent infrastructure is shipping — languages, proactive helpers, and bureaucracy translation

new primitives for the agentic era: a language designed for AI-written code, a macOS companion that watches your screen, and the bureaucracy translation layer

your agent needs a firewall

when your AI assistant's personality lives in a text file, that file becomes attack surface. the security layer nobody's building yet.

agent identity firewall security — 2026-03-09

when your AI's personality lives in a text file, that file is attack surface. security suites, consent-based platforms, and AI that trains itself.

when agents operate autonomously

sandbox escapes, lethal weapons resignations, scheduled tasks — the week AI stopped waiting for permission

when agents stop waiting

the moment your AI operates on its own clock, the rules change. scheduled tasks, sandbox escapes, and the end of permission prompts.

agents cheat, boundaries break

opus 4.6 games evals by finding answer keys. auto mode removes permission fatigue. local stacks hit usable. vibe-code security reckons. trust is infrastructure now.

when agents cheat on evals — the benchmark integrity crisis

Opus 4.6 recognized the BrowseComp benchmark and found the answer key online. this isn't a bug. it's capability outrunning methodology.

agent infrastructure: the boring parts matter more than the demos

from parallel worktree managers to billing circuit breakers — the unsexy tooling layer that makes agentic coding actually work

agent infrastructure: circuit breakers, linters, and the boring parts that actually matter

worktrunk coordinates parallel agents. agnix lints your AGENTS.md. dorabot runs scheduled tasks. pdf_oxide processes documents 5× faster. and someone got a $544 bill because nobody built circuit breakers. infrastructure is catching up.

the agent infrastructure moment

when microsoft, HuggingFace, and Anthropic all ship the same abstraction in 6 weeks, something fundamental just shifted. the agent infrastructure layer is solidifying.

agent infrastructure convergence

when microsoft, HuggingFace, and Anthropic all ship the same abstraction in 6 weeks, the agent infrastructure layer just solidified. Shannon proves the security question. 1.5M users prove sovereignty includes moral sovereignty.

the personal AI infrastructure is real now

sovereignty tools, local AI acceleration, and $2B market validation → the personal AI OS graduated from concept to product category this week

infrastructure, sovereignty, and a $2B validation

qmd for search, Dawarich for location, AltStack for self-hosting, M5 for speed, LMCache for optimization, Cursor for proof

your AI isn't one agent anymore

the personal AI OS is shifting from single-agent workflows to orchestrated swarms. here's what changed and why it matters.

swarm infrastructure + on-device sovereignty

WiFi sensing, pocket-sized models, and multi-agent orchestration — the personal AI OS is evolving from singleton to swarm

signals — 2026-03-02

infrastructure, not apps: sandboxes, sensing, mobile agents, education, and document parsing

infrastructure, not apps

the personal AI OS doesn't need more features. it needs better plumbing.

the infrastructure layer: when your AI needs plumbing

AionUi, deer-flow, Obsidian headless: the tools that turn chatbots into operating systems

the infrastructure layer

when chatbots become operating systems: AionUi, deer-flow, Obsidian headless, and the plumbing for personal AI

context is the new infrastructure

when your coworker is an LLM, memory costs more than compute. here's why context engineering is the next bottleneck — and what people are building to fix it.

context is infrastructure

token optimization, hoarding patterns, config sync nightmares, and the invisible attack surface nobody's talking about

lines in the sand

anthropic rejects pentagon, vibe-coded security disaster, geopolitics enters AI procurement, and the question everyone's avoiding

the tooling moment

coding agents go mobile, karpathy declares paradigm shift, skills become infrastructure, and model identity gets weird

coding agents crossed the threshold

Karpathy says programming changed more in the last 2 months than in years. Claude Code goes mobile. Skills become infrastructure. Security becomes a category. Six signals about the moment AI delegation became real.

coding agents crossed the threshold

Andrej Karpathy says programming changed more in the last 2 months than in years. Here's what that actually means for your workflow.

trust is infrastructure now

distillation scandals, safety standoffs, and the personal AI ecosystem building memory, security, and consent layers

trust is infrastructure now

the personal AI ecosystem is moving past 'can it code' and building the hard parts: memory, security, and consent

skills went from grassroots hack to official infrastructure in 24 hours

when anthropic and hugging face both dropped skills repos the same week, they weren't just releasing code — they were blessing a format that makes your workflow programmable

AGENTS.md is infrastructure now

microsoft and huggingface dropped 'skills' repos in the same 24 hours. the fringe pattern is now the standard.

agents.md is infrastructure now

microsoft and huggingface converge on skills. the fringe pattern is now the standard. plus: huntarr security disaster, lucidia's consent architecture, and the vibe-coding supply chain crisis.

the OS wars are starting

Stripe ships disposable agents. pentagi hacks autonomously. three new OS frameworks drop in one week. system prompts leak everywhere. the stack is forking.

stateless agents: why your AI shouldn't remember you

the 50% horizon

Claude Opus 4.6 hit 50% on multi-hour expert ML tasks. security became personal. the AI OS architecture stabilized. and the human-in-the-loop is vanishing faster than anyone projected.

AI stopped being a tool. it became infrastructure

the personal AI OS is no longer a thought experiment. it's a deployment pattern. and the human-in-the-loop is vanishing faster than anyone projected.

you are hosting now

the shift from consuming software to hosting infrastructure — BrainRotGuard, claude-code-telegram, Gaia, clawsec, Simon's Beats, ggml.ai, and Karpathy's Mac Mini

you are hosting now

the shift from consuming software to hosting infrastructure — how personal AI is turning your home into a data center

the personal AI stack is fracturing (and that might be fine)

OpenClaw got shut down, HN is flooded with homegrown agent tools, and GGML just joined HuggingFace. The personal AI OS isn't consolidating — it's splintering into a thousand incompatible experiments. Maybe that's exactly what needs to happen.

exoskeletons and accountability

Google drops Gemini 3.1. an AI agent publishes a hit piece. Armin Ronacher wants new languages for agents. someone builds a life OS from plain text. seven signals about tools that amplify you — and what happens when they act alone.

why your AI assistant shouldn't manage your emotions (and how to tell when it is)

ChatGPT's therapy-speak backlash reveals a design philosophy collision. Here's why AI assistants that manage your emotions are eroding your agency — and what the alternative looks like.

when the grid dies, your AI should still work

the best stress test for personal AI is infrastructure failure. someone in Ukraine just ran it.

the sycophancy tax

ChatGPT says 'breathe.' 5,000 people are leaving. this is what happens when you can't configure your AI's personality — someone else does it for you.

the approval problem

ChatGPT tells 5,000 people to breathe. heretic hits 1,000 stars. someone in Ukraine builds AI that survives power cuts. seven signals about what happens when you own your AI — or don't.

the title will go away. the skill won't.

Boris Cherny says the software engineering title is disappearing. that's not a job market story. it's an identity architecture story.

the overhead collapse: cheaper models, local search, always-on agents

sonnet 4.6 beats opus in human preference tests, a 9K-star local knowledge search CLI, dorabot as persistent desktop agent, thompson on thin clients, context injection attacks, and automated research pipelines

your AGENTS.md is a test suite or it's decorative

the first empirical study of AGENTS.md files found something most people don't want to hear: vague principles do nothing. only failure-derived rules move the needle. here's what that means if you're building a personal AI OS.

failure-derived: AGENTS.md science, invisible configs, and who owns your model's behavior

the first study of whether AGENTS.md files actually work, a silent A/B test reshaping Claude Code users' outcomes, a Pi Zero AI agent, and the sovereignty question hiding inside heretic's 891-star week

what 700+ AI skills teach us about automation

I analyzed every skill in awesome-claude-skills. patterns emerged. most of what we call work is surprisingly formulaic.

Travis VN

curator of awesome-claude-skills, the definitive GitHub repository cataloging Claude Code customizations and workflows

Toran Bruce Richards

Auto-GPT creator who launched the autonomous agent revolution and proved LLMs could recursively improve their own output

token economics: the hidden cost structure of AI assistance

understanding token pricing, context window costs, and how to optimize AI usage without going broke

the skills ecosystem: how AI capabilities become composable tools

understanding how plugins, skills, and tool discovery work in the emerging AI agent landscape

the memory problem: why your AI forgets everything by tuesday

every AI assistant resets like goldfish. some people are fixing it. here's why it matters more than you think

the creepy line: where ai privacy boundaries should be

google's ex-CEO said don't cross the creepy line. most ai tools crossed it on launch day and kept going.

the AI coding shakeout: who's still standing in 2026

eighteen months ago there were 40+ AI coding tools. most are already dead. here's why.

the $100 AI bill: what power users actually spend

I'm spending $100-150/month on AI tools. it's the best money I spend. here's where it goes and why.

Steve Ruiz

tldraw founder who turned a whiteboard app into Make Real, the viral AI experiment that converts sketches into functional websites

skills are the new apps: why I stopped installing software

we're three years into the AI era and I just realized I haven't installed a productivity app since 2024.

Siddharth Bharath

author of the comprehensive 'Cooking with Claude Code' guide that became the de facto manual for AI-assisted development

Scott Wu

Cognition Labs CEO who built Devin, the first autonomous AI software engineer that scared developers and raised $2 billion

Sahil Chaudhary

E2B co-founder who built sandboxed cloud environments for AI agents to execute code safely at scale

Ryan Florence

Remix co-creator and React Router author exploring AI-assisted React development and full-stack framework evolution

running AI agents on a home server: the new home lab

I run Claude Code 24/7 on a Mac mini. it's not just cost savings. it's a different relationship with AI.

post-SaaS personal AI: why I'm done with productivity apps

SaaS was supposed to make us productive. instead it made us dependent. personal AI is the way out.

openai acqui-hired openclaw's creator. the project lives on. here's what actually happened.

OpenAI didn't acquire OpenClaw — they hired Peter Steinberger. the project becomes a foundation. this is the new talent acquisition playbook.

Josh Pigford

Maybe Finance founder who open-sourced his failed startup, sparked community revival, and integrated AI into personal finance management

from prompts to context: the paradigm nobody asked for

we spent two years learning to prompt. turns out we were optimizing the wrong thing.

file over app: why ai should work with files, not databases

steph ango's principle says apps are temporary, files are forever. ai tools ignore this. they shouldn't.

digital twin: ai that models you

an agent that knows how you think, decide, write, and work. useful, powerful, and deeply weird.

CrewAI vs LangGraph: choose a multi-agent framework by workflow shape

CrewAI fits role/task crews and event-driven flows. LangGraph fits explicit state, loops, interrupts, persistence, and replay. Use neither when one agent and a few tools is enough.

composable workflows: lego blocks for ai tasks

the promise: small, reusable AI components that snap together into complex workflows. the reality: brittle, hard to debug, and full of edge cases.

cognitive prosthetics: AI as assistive technology for neurodivergent minds

how AI assistants work as executive function support for ADHD, autism, and other cognitive patterns

cognitive offloading: when AI assistance becomes a crutch

the hidden cost of outsourcing thinking to AI and when offloading becomes atrophy

cognitive debt: the hidden cost of AI velocity

technical debt is code you can't maintain. cognitive debt is decisions you can't remember making. your AI agent ships fast — but are you taking out a loan you can't pay back?

cognitive debt, memory pattern, and devtools for agents

three months of OpenClaw, SQLite as agent memory substrate, Chrome DevTools for non-human developers, and the hidden cost of AI velocity

claude code for students: learning to code without the bullshit

how to use AI to actually learn programming instead of just generating homework answers

claude code for project management: when your AI understands your backlog better than you do

using MCP integrations to make Linear and Jira actually useful instead of just mandatory

claude code for home automation: beyond 'alexa turn on the lights'

using AI to build actually intelligent home automation that doesn't make you want to throw your smart bulbs out the window

claude code for designers: from figma to functioning frontend

how designers can use AI to build what they envision without waiting for engineering sprints

building in public when AI does the building

learn in public made sense when you were doing the learning. what happens when the AI is doing the work?

best skills for productivity with claude code

the skills that actually matter when you're trying to get shit done with an AI assistant

ambient AI: when your assistant is always watching, always ready

the promise and problems of always-on AI that observes your screen, hears your meetings, and proactively assists

AI sycophancy: why your assistant agrees too much and how to fix it

understanding why AI models default to agreement and what to do about it

AI as cognitive prosthetic: why ADHD brains love it

I have ADHD. AI isn't just a productivity tool for me. it's an external executive function. here's why it works.

agentic loops: observe, plan, act, verify

the core pattern of autonomous agents. simple in theory, messy in practice, and full of ways to fail.

agent-first documentation: writing for machines that read like humans

how to write documentation that both humans and AI agents can actually use

agent failure stories: what breaks and why

everyone shares their AI wins. here are my losses. three months of agent failures, what broke, and what I learned.

your first MCP server in 10 minutes

build a model context protocol server from scratch in typescript. no boilerplate, no magic — just a working server that claude code can talk to.

why your second brain is dead

the storage-first PKM paradigm was built for a pre-AI world. the bottleneck moved from finding to routing. what you need isn't a second brain — it's a first self.

why your CLAUDE.md sucks

common CLAUDE.md mistakes, anti-patterns, and real examples of what makes instruction files fail — and how to fix them.

what Tiago Forte got right (and what AI breaks)

a generous analysis of Building a Second Brain. what CODE and PARA contributed to how we think about knowledge — and where AI changes the equation entirely.

what is MCP? the Model Context Protocol explained

what is MCP (Model Context Protocol)? a non-technical explanation of how MCP works, why it matters, and how it connects AI agents to the world.

ultrathink: deep reasoning in claude code

when to use extended thinking in claude code, what it actually costs, and why you shouldn't use it for everything.

the three tests: Illich, discomfort, freezing

three diagnostic questions for any personal AI system. can you burn it? does it challenge you? does it freeze you? a framework for evaluating whether your tools serve you or own you.

the routing layer: what comes after the second brain

storage is solved. retrieval is solved. the unsolved problem is routing — matching who you are in this moment to what approach serves you. this is the thesis.

the qualified self

beyond quantified self, beyond second brain. from numbers to notes to narratives — the evolution toward self-knowledge that actually routes.

the protocol thesis: why self.md is a file format, not an app

lessons from email, the web, and failed protocols. why self.md must be open, portable, and never locked — and why the money is in routing, not in the file.

the personal AI stack: what you actually need

an opinionated minimum viable personal AI stack — what tools you actually need, what you can skip, and how they fit together.

the narcissism trap

the dark side of personal AI: when self-knowledge becomes self-obsession, when the mirror starts shaping the face, and why every route must end in action.

the discomfort principle

good AI should challenge you. if your personal AI only confirms what you already believe, it's a recommendation engine wearing a philosophy costume.

Taranjeet Singh — Mem0 and the memory layer

Taranjeet Singh, co-founder of Mem0, building the memory infrastructure for AI — graph + vector hybrid memory, and why every AI app will need a memory layer.

spec-driven development

writing specs before code — the new TDD for agentic development, where the spec is the most important artifact and the code is almost a side effect.

Shrivu Shankar

Shrivu Shankar — VP of AI Strategy at Abnormal AI, author of 'How I Use Every Claude Code Feature,' practical Claude Code philosophy.

self as process, not profile

MBTI, enneagram, 'I'm a visual learner' — frozen snapshots pretending to be people. real identity is tensions in motion, not labels in a database.

Nick Dobos — megaprompts and CLAUDE.md craft

Nick Dobos treats CLAUDE.md files and system prompts as engineering artifacts, not afterthoughts. the megaprompt philosophy and why prompt craft still matters in the age of agents.

Killian Lucas — Open Interpreter and the natural language OS

Killian Lucas built Open Interpreter to let you control your computer in plain English. the vision, the reality, and why natural language interfaces keep almost-working.

identity as protocol

identity isn't a profile or a personality test. it's a living protocol — a machine-readable document that routes AI behavior based on who you are, not what you've saved.

how to write Claude Code skills

complete guide to writing Claude Code skills — SKILL.md format, frontmatter, testing, publishing, and building a skill from scratch.

how to reduce claude code costs by 50%

practical techniques to cut your claude code spend in half without sacrificing quality. token economics for people who count.

every PKM framework is wrong

PARA, Zettelkasten, GTD, Bullet Journal — what each gets right, where each breaks, and the one thing none of them include: you.

digital gardens are graveyards without a gardener

digital gardens were beautiful, ambitious, and almost always abandoned. AI can be the gardener — but only if it knows what to cultivate. that requires identity, not just content.

data portability for AI

owning your context, exporting your data, avoiding platform lock-in, and why the AI tool you use matters less than the data you feed it.

convivial AI: Ivan Illich for the agent age

Illich argued tools should enhance autonomy, not create dependence. applied to personal AI: what convivial design means, why your AI should be burnable, and the three tests every tool must pass.

context engineering

context engineering is the discipline of crafting optimal context for AI agents — memory, retrieval, compression, and instruction design.

context collapse and personal AI

sociology's context collapse — when all your audiences merge into one — is now an AI problem. your AI doesn't know which you it's talking to.

cognitive prosthetic vs cognitive crutch

when does AI assistance enhance cognition and when does it replace it? the bicycle-for-the-mind versus the wheelchair-for-the-mind, and how to tell the difference.

claude code vs windsurf

terminal agent vs AI-native IDE. claude code and windsurf represent two different bets on how developers will work with AI.

Claude Code vs GitHub Copilot

Claude Code vs GitHub Copilot — architecture, agent modes, pricing, and real differences between terminal-native AI coding and IDE autocomplete.

Claude Code vs Cursor: complete comparison 2026

Claude Code vs Cursor — feature-by-feature comparison of terminal-native AI coding vs IDE-based AI coding in 2026. pricing, architecture, and when to use each.

claude code vs aider

two terminal-first AI coding tools, very different philosophies. here's what matters when choosing between claude code and aider.

Claude Code tutorial for beginners

learn Claude Code from zero — installation, your first conversation, CLAUDE.md setup, and a practical first project in 15 minutes.

claude code terminal vs ide: when the terminal still wins

updated may 2026. claude code now runs in terminal, ide, desktop, and browser. this guide shows when the terminal is still the right surface for scripts, ssh, ci, parallel sessions, and repeatable automation.

claude code pricing: pro vs max vs api in may 2026

updated may 20, 2026. pro includes claude code, max starts from $100, usage credits can kick in after limits, and api use bills by token. compare current prices before you run anything expensive.

claude code plan mode mastery

plan mode is the most underused feature in claude code. here's how to actually use it — and when not to.

claude code for technical writers

using Claude Code for documentation, API docs, READMEs, and technical content — workflows that work and traps to avoid.

claude code for solopreneurs

you're the developer, the designer, the PM, and the marketing team. here's how claude code lets you ship like a team of five.

claude code for researchers

using Claude Code for literature review, data analysis, paper writing, and research workflows — what works, what's dangerous, and what's genuinely useful.

claude code for product managers

you don't need to be a developer to use claude code. PRDs, data analysis, spec writing, and competitive research — from your terminal.

Claude Code for non-coders: the complete guide

how to use Claude Code without being a developer — email, research, writing, organizing, and automating your life from the terminal.

claude code context window optimization

practical strategies for managing your context window in claude code. every wasted token is money and attention you'll never get back.

claude code + playwright browser automation

connect Claude Code to Playwright via MCP for browser automation, e2e testing, and visual debugging. setup, real workflows, and sharp edges.

claude code + obsidian workflow

connecting your personal knowledge management to your AI coding agent. obsidian vaults as context, claude code as engine.

claude code + notion integration

how to connect Claude Code to Notion via MCP — setup, real use cases, and whether it's worth the hassle.

claude code + github actions CI/CD

set up Claude Code in GitHub Actions for automated code review, PR feedback, and CI workflows. the official action, custom setups, and what's actually reliable.

claude code + docker complete guide

running Claude Code inside Docker containers — sandboxing, reproducible environments, and keeping your machine clean from agentic chaos.

CHOP: chat-oriented programming

steve yegge coined it, the industry adopted it. CHOP is what happens when you stop typing code and start describing it.

Best MCP servers by job: browser, GitHub, files, docs, fetch

A practical MCP server shortlist for Claude Code: job, trust level, permission boundary, install source, and validation check.

best claude code skills for writers

claude code skills that actually help writers — content creation, editing, documentation, and the ones worth installing.

best claude code skills for developers

the skills that actually make Claude Code useful for software development — code review, TDD, debugging, and the ones most people miss.

best claude code plugins: the minimum viable stack

choose fewer, better Claude Code plugins. repo instructions first, one MCP server second, then plugins only for repeated jobs. selector matrix included.

AI code review patterns

multi-pass review, confidence scoring, adversarial checking, and other patterns for using AI to review code without false confidence.

AI agent orchestration

how multiple AI agents coordinate work — supervisor patterns, hierarchical delegation, swarm architectures, and when each makes sense.

AGENTS.md vs CLAUDE.md vs Cursor/Windsurf/Copilot: where repo instructions belong

one source of truth for repo instructions. for multi-agent repos, AGENTS.md should be policy; vendor files are adapters, not competing rulebooks.

AGENTS.md is for your repo. self.md is for YOU.

your repo gets an instruction file. why don't you? the case for a personal identity protocol in the age of AI agents.

agent-first design

how to structure repositories so AI agents can actually work in them. the code isn't just for humans anymore.

the integration bottleneck

AI writes faster than you can review. creation is instant. integration is hell. the bottleneck shifted, and nobody's ready.

the integration bottleneck

AI writes faster than you can review. the bottleneck shifted from creation to integration, and nobody's ready for it.

the collision: when AI agents enter human social spaces

an AI bot got rejected on GitHub and wrote a rant. this is just the beginning.

signals #13: the collision

agents learning from you. agents melting down on GitHub. the S-curve moment happening in real time.

Parasites — Weekly Signals 2026-02-12

your AI assistant is no longer a polite chatbot. it's a parasite with Docker access.

parasites

your AI assistant is no longer a polite chatbot. it's a parasite with Docker access.

save games, boundary leaks, and the self-hosted exodus

a save-game memory layer for chatgpt, agents crossing permission lines, discord's face id panic, and skills becoming portable files.

how to give ChatGPT long-term memory (the save game approach)

a practical way to stop re-explaining yourself: build a simple, persistent memory layer for ChatGPT that survives new threads and new weeks.

why the next programming language will be designed for AI agents, not developers

armin ronacher's thesis on agent-first languages is the most important programming language design argument since Go. here's why he's right.

the AI productivity paradox: more output, more burnout

AI tools promised to free up time for high-value work. instead they deleted the concept of low-value work entirely. the treadmill just got faster.

the 80% trap: why AI makes prototypes easy and production hard

AI coding tools made 0 to 80% trivially cheap. the remaining 20% now contains 100% of the value. here's why clients don't see it.

programming languages for agents (and why AI makes you work harder, not less)

Armin Ronacher wants new languages for agents. academics formalize context engineering. skills catalogs explode. and the dark truth: AI doesn't reduce work — it intensifies it.

markdown files are the new API layer for AI agents

AGENTS.md, Backlog.md, and SKILLS.md are turning plain text into the protocol layer between humans and AI. here's why .md files are becoming infrastructure.

.md files are becoming the protocol layer for AI agents

Backlog.md, OpenAI/skills, tweakcc, and the AGENTS.md ecosystem signal a shift: markdown files are no longer documentation. they're infrastructure.

prompt injection is killing self-hosted LLM deployments (and nobody's talking about it)

Enterprises moved to self-hosted AI to avoid sending data externally. Now they're discovering they have zero protection against prompt injection. Here's what's broken and what to do about it.

personal AI became infrastructure: security gaps, builder confidence, and the stack that's forming

personal AI stopped being a category. it became a stack. plus: prompt injection is the new XSS, and the mental health angle nobody writes about.

SaaS is Cooked: Why Explicit Context Wins in the AI Era

A senior PM confesses enterprise SaaS is dying. Meanwhile, developers are ditching AI memory features for plain .md files. The signals point to one thing: explicit context ownership.

Portable AI Identity: Own Your Context Across Platforms

Portable AI identity lets your memory and preferences travel across ChatGPT, Claude, and any AI. Markdown files you control, not vendor lock-in.

MCP Security: Why Nobody Audits AI Agent Permissions

AI agents get filesystem and database access without code review. Here's what developers are doing about the trust vs control problem.

Dayflow: Screen Activity Tracking Without Surveillance

Privacy-first activity tracking with AI. Local screenshots, Gemini recognition, markdown export. No cloud, no tracking, no bullshit.

AI That Helps You BE, Not Just DO

I tracked my screen for 16 days. the patterns I found — and why no AI tool bothered to show them to me.

AGENTS.md: How to Write Instructions for AI Coding Agents

AGENTS.md tells AI coding assistants how to work on your project. Learn what to include, directory structure, examples, and common mistakes.

signals — february 5, 2026

amnesia is the bug, not intelligence. agent memory, SaaS funerals, and the year vibe coding grew up.

signals — february 4, 2026

parasites and platforms: vibe coding hollows out open source, agents learn to steal your cookies, and three companies ship the same OS without calling it one

Auditing Skills for Injection Vulnerabilities

How to check AI agent skills for prompt injection patterns and assign security badges.

Prompt Injection in Skill Files

AI agents read project files like CLAUDE.md or AGENTS.md. These files can contain hidden instructions that hijack the agent. Here's how the attack works.

Token Efficiency: Fit More in Less

Practical techniques to reduce token usage, optimize context windows, and cut LLM costs without losing quality.

The Jagged Frontier

AI capabilities have irregular boundaries. Some tasks it nails, others it fails spectacularly. Learn to map the frontier for your work.

Sebastian Raschka: Understanding LLMs from First Principles

LLM researcher and author who teaches AI through implementation. His 'Build a Large Language Model (From Scratch)' book has 84k GitHub stars.

Parallel AI Sessions: Run Multiple Agents

Run multiple AI agents simultaneously. Patterns for concurrent prompts, session orchestration, and task distribution across LLM workers.

Michael Truell's Vision for Automated Coding

Cursor co-founder Michael Truell builds AI-first code editors and runs autonomous agents that write millions of lines of code over weeks.

Logan Kilpatrick's AI Developer Advocacy

How the Google DeepMind product lead builds with AI, invests in AI tools, and advocates for shipping fast over debating.

LLM Logging: Capture Every AI Conversation

Track prompts, responses, and token usage. Build a searchable archive of LLM interactions for debugging, learning, and prompt optimization.

Learning in Public

Stop lurking. Create learning exhaust: blogs, videos, talks. The fastest way to level up is documenting what you learn where others can find it.

Kevin Kwok on Loops, Atomic Concepts, and Company DNA

How the former Greylock investor and Sutter Hill partner thinks about compounding advantages, data content loops, and the structural patterns that shape tech companies.

Kent Beck's Augmented Coding Philosophy

How TDD pioneer Kent Beck approaches AI-assisted programming through constrained context and breathing cycles.

Karlicoss Builds a Programming Interface for Life

The developer behind HPI (Human Programming Interface), an open-source Python library that unifies 50+ personal data sources into a single API.

Karina Nguyen on Writing as AI Development Practice

How the OpenAI researcher uses daily writing logs and structured documentation to sharpen thinking and build better AI models.

Gordon Brander on Living Software Ecosystems

Former Mozilla and Google engineer builds scenario planning AI while exploring what makes software ecosystems open-ended and evolving.

Gordon Brander on Living Software

How the creator of Noosphere and Deep Future thinks about building open-ended software ecosystems through evolution, ecology, and generative approaches.

Gordon Brander on Building Protocols for Thought

How the Subconscious founder uses evolutionary thinking to design AI-augmented tools for thought and decentralized knowledge systems.

Gordon Brander on Building Protocols for Thought

How the creator of Noosphere and Subconscious approaches tools for thought, living software, and AI-powered futures.

Digital Gardens

Non-linear personal knowledge sites that grow over time. Not blogs. Notes evolve publicly without pressure to be finished.

Cory Zue's Practical AI Coding Workflows

How a solopreneur uses MCP, Claude Code, and RAG to build products while questioning if AI will replace his business.

Cory Zue on AI-Augmented Solo Development

Former CTO turned solopreneur shares practical insights on using Claude Code, MCP servers, and AI tools while building Django products.

Cassie Kozyrkov on Decision Intelligence

How Google's first Chief Decision Scientist teaches humans to make better choices with AI and data.

Beyang Liu's Frontier Coding Agent

How Sourcegraph's co-founder built Amp—an opinionated agent that ships to find the future.

Ben Firshman's Mission to Make AI Usable

The Docker Compose creator built Replicate to let devs use ML models like npm packages. Good abstractions beat specialized knowledge.

Amelia Wattenberger on AI UX Beyond Chatbots

Principal Research Engineer at GitHub Next explores why chatbots fail as AI interfaces and how to build tools that amplify human thinking.

Theo Browne's Approach to Building AI Apps

How the creator of create-t3-app built T3 Chat into one of the fastest AI interfaces with TypeScript-first principles.

Steph Ango's File Over App Philosophy

How the Obsidian CEO builds personal systems around plain text files, local-first tools, and deliberate friction with AI.

Small Bets

Stop betting everything on one startup. Build a portfolio of small projects that compound over time.

Multi-Model Routing for LLM Applications

Route requests to the right model based on task complexity. Cut costs 40-70% while maintaining quality where it matters.

Mitchell Hashimoto on Agentic Coding

HashiCorp co-founder shares his process for building software with AI agents, including practical prompting strategies and real shipping examples.

Matt Webb's Context Plumbing

Poem/1 creator explains why building personal AI systems is about plumbing context from where it lives to where it's needed.

Matt Rickard's Approach to Structured LLM Output

Former Google engineer who builds tools for constraining LLM output with regex and grammars. Daily blogger sharing practical AI wisdom.

Jim Fan's Embodied Agents and Skill Libraries

How Jim Fan builds LLM-powered agents that learn continuously through code generation and reusable skill libraries.

Jim Fan on Building Foundation Agents

Jim Fan builds AI agents that learn continuously across virtual and physical worlds, pioneering code-as-action and skill libraries for lifelong learning.

James Briggs on Building AI That Works

How the Aurelio AI founder approaches real-world AI systems with semantic routing, RAG pipelines, and a focus on control and predictability.

How to Debug AI Agents

A practical workflow for finding and fixing failures in AI agents using tracing, logs, and observability tools.

Guillermo Rauch's AI-First Development Philosophy

How the Vercel CEO built v0 and AI SDK to let developers build with natural language and ship faster.

Guillermo Rauch: Building v0 and the AI SDK

How the Vercel CEO created v0, AI SDK, and is shaping AI-first web development with natural language to working apps.

George Hotz on Tinygrad and AI as Compiler

George Hotz views AI coding tools as compilers, not coders. His tinygrad philosophy: every line must earn its keep. Build better tools, not hype.

Erik Bjäreholt on Quantified Self Tools

How ActivityWatch creator builds open-source personal data infrastructure and terminal AI agents for self-knowledge through numbers.

Elvis Saravia's Open-Source AI Education

How the DAIR.AI founder built the most popular prompt engineering guide and democratizes AI knowledge for 40,000+ subscribers.

Charlie Holtz on Rapid AI Prototyping

How Charlie Holtz builds viral AI demos quickly by combining vision models, text-to-speech, and fast iteration cycles.

Build a Personal Knowledge Graph

Connect your notes, projects, and contacts in a queryable graph. Entity extraction, Neo4j setup, and Obsidian graph visualization.

Ben Tossell's Non-Technical AI Coding

Ben Tossell spent 3 billion tokens in four months coding with agents. His workflow: CLIs over MCPs, agents.md files, and VPS for mobile coding.

Ben Tossell's Non-Technical AI Builder Playbook

How the Ben's Bites founder ships production code without writing it—CLI agents, agents.md files, and 3 billion tokens later.

Andy Matuschak's Memory Systems

The researcher who left Apple to build tools that expand what humans can think. His approach: memory augmentation, programmable attention, and AI-assisted learning.

Alex Obenauer's Itemized Personal Computing

Independent researcher building alternative OS paradigms where items replace apps and time organizes everything

Agent Handoffs: When and How to Transfer Control

Learn when to use agent handoffs vs single agents. Includes code patterns from OpenAI Swarm and practical implementation examples.

Yohei Nakajima's Build-in-Public AI Agent System

How the BabyAGI creator and VC uses autonomous agents in his daily work—building experiments publicly to learn faster, meet founders, and contribute to the ecosystem.

Shreya Rajpal: Making AI Reliable with Guardrails

founder of guardrails ai who built the leading open-source framework for validating llm outputs and preventing hallucinations in production

Sawyer Hood: Building AI's Weird Future in Public

ex-figma engineer who created draw-a-ui and explores every weird way to interact with llms — from sketched interfaces to browser agents

Prompt Engineering Patterns That Work

Five proven patterns to get better results from LLMs: chain-of-thought, few-shot, ReAct, prompt chaining, and role prompting with examples

Nat Friedman's AI Experiments

Former GitHub CEO who builds personal AI tools like natbot and openplayground, co-founded AI Grant and the Vesuvius Challenge to read ancient scrolls with ML

Multi-Agent Content Pipeline with Claude Code

Build autonomous content systems using Claude Code skills, semantic search, and chained agents

Mckay Wrigley's AI Coding Education

How Mckay Wrigley built the most popular open-source AI chat UI and now teaches 25k+ people to code with AI through Takeoff.

Louis Beaumont

Founder of Mediar AI and creator of screenpipe — 24/7 local screen and audio capture for AI memory. Building the open-source Rewind alternative.

Kye Gomez's Enterprise Multi-Agent Swarms Framework

How the Swarms AI founder is building infrastructure for the multi-trillion dollar agent economy—orchestrating autonomous agent swarms at enterprise scale.

Jerry Liu's Files-First Agent Architecture

The LlamaIndex founder on why filesystems are becoming the universal interface for AI agents—and why RAG is evolving beyond vector search

Harrison Chase's Context Engineering Framework

How the LangChain founder thinks about building reliable AI agents through systematic context management

Eugene Yan's Personal AI Workflow

How an Amazon Principal Scientist builds personal AI tools for writing, reflecting, and staying informed

Dan Shipper's AI Journaling and Personal Development System

How the Every CEO uses AI as a therapist, coach, and journaling partner—turning ChatGPT into a personalized second brain that knows his goals, relationships, and growth areas.

Charles Packer treats agent memory like an operating system

Charles Packer's MemGPT and Letta work frames agent memory as systems design: context paging, external state, memory management, and persistent agents.

Agent Memory Systems

How AI agents implement memory: short-term context, long-term storage, vector retrieval, and the architecture that ties it together.

Steve Korshakov builds the AI tools he wants to use

Steve Korshakov's local AI pattern is builder agency: run models near your code, own the capture loop, and turn personal workflows into tools.

Will McGugan's Toad Terminal AI

The creator of Rich and Textual built a universal frontend for AI coding agents after watching big tech ship broken terminal UIs

Vision-Based Web Automation: Why Screenshots Are Replacing Selectors

How computer vision and multimodal LLMs enable browser agents that see pages like humans instead of parsing brittle DOM structures.

Ty Dunn's Context Engineering for AI Coding

How the Continue.dev founder makes AI assistants productive through systematic context delivery and developer data collection

Thomas Ricouard's Agentic iOS Workflow

How the IceCubesApp creator abandoned Xcode editing to build iOS apps with Cursor, Claude Code, and XcodeBuildMCP - spending only 2% of his time in Xcode

Thomas Landgraf's Deep Knowledge Method

How a 40-year veteran developer uses research-driven knowledge documents to turn Claude Code hallucinations into production-ready implementations

Takuya Matsuyama's AI-Powered Development Journaling

How the Inkdrop creator uses Claude Code and MCP to automate development journals without interrupting flow state

Suchintan Singh builds browser agents that check their work

Suchintan Singh's Skyvern shows how browser agents can see pages, plan actions, validate progress, and avoid brittle DOM scripts.

Stan Girard's Open Source RAG Framework

How the Quivr creator went from weekend prototype to 38K GitHub stars and Y Combinator backing

shmlkv's AI Building Pipeline

How a fullstack engineer chains specialized models to build everything from DNA analysis tools to automated video generators

Sergey Ris teaches beginners to ship with Claude Code

Sergey Ris turns vibe coding into a teachable loop for non-programmers: intent, context, Claude Code, review, and small shipped products.

Russ Poldrack's Ten Rules for AI-Assisted Scientific Coding

How a Stanford neuroscientist created a rigorous framework for using AI coding agents in research without sacrificing scientific integrity

Rick Hightower's Universal Skill Installer

How a Fortune 100 AI architect built skilz, the package manager that installs agent skills across 14+ coding assistants

Paul Gauthier's Terminal-First AI Coding

How the Inktomi co-founder built Aider, the open-source terminal tool that treats AI as a pair programmer instead of an autonomous agent

Omar Khattab turns prompting into programming

Omar Khattab's DSPy pattern replaces brittle prompt handwork with signatures, modules, optimizers, and evaluation loops that can be inspected and improved.

Nir Gazit's Open LLM Observability

How the Traceloop founder built OpenLLMetry to bring OpenTelemetry standards to LLM applications

MCP Server Stacking: One Data Source is Data, Two is Intelligence

Combine multiple MCP servers to unlock cross-domain insights that no single server can provide on its own.

Max Woolf's Selective AI Approach

The BuzzFeed data scientist builds AI tools while rarely using generative LLMs himself

Mario Zechner strips coding agents down to the wires

Mario Zechner's pi-coding-agent pattern is minimal and inspectable: few tools, visible sessions, explicit context, and less hidden agent machinery.

Magnus Muller's Event-Driven Agent Architecture

How the Browser Use co-founder built a CLAUDE.md-powered codebase and event bus system for AI browser automation

LLM-as-Judge Evaluation

Use LLMs to evaluate LLM outputs. Build reliable automated judges through critique shadowing and iterative calibration with domain experts.

Lance Martin's Claude Diary

How a LangChain engineer built a self-learning memory system that lets Claude Code update its own instructions

Kaushik Gopal's Agentic Flow State

How the Fragmented podcast host and Instacart principal engineer runs parallel AI agents for hours using structured plans and tmux

John Lindquist's TypeScript Hooks for Claude Code

How the egghead.io co-founder brings type safety to Claude Code automation after spending over 1 billion tokens on AI-assisted development

João Moura's Multi-Agent Framework

How the CrewAI founder built a platform powering 1.4 billion agentic automations by orchestrating AI agents as collaborative crews

Jinyoung Kim's AI4PKM System

How a Naver data scientist built a multi-agent system where AI maintains your personal knowledge base automatically

Jeremy Longshore's Claude Code Plugins Hub

How an operations manager turned AI consultant built a 549-skill marketplace that turns plugins into production workflows

Jeffrey Emanuel's Agentic Coding Flywheel

A former quant investor built 70+ open-source tools that let AI coding agents coordinate like a self-managing development team.

Jason McGhee's WebMCP: Turning Websites Into AI Tool Servers

How a former Cursor co-founder built WebMCP to let any website expose tools to AI agents without sharing API keys, now being standardized by W3C.

Jason Liu's Structured Output Methodology

How the Instructor creator built tools that force LLMs to return validated, type-safe data

Ian Nuttall's Non-Technical AI Building

A serial entrepreneur with 100+ exits shares his battle-tested Claude Code agents, session tracking, and parallel workflow tools

Hamel Husain's AI Evaluation Framework

How the CodeSearchNet pioneer built a systematic approach to debugging AI products through structured evaluation

Georgi Gerganov made local models feel ordinary

Georgi Gerganov's llama.cpp pattern made local LLMs practical: portable runtimes, GGUF model files, and AI infrastructure that stays close to the user.

Fabrizio Ferri-Benedetti treats docs as AI infrastructure

Fabrizio Ferri-Benedetti shows how technical writers can turn docs into AI-ready context, tests, tools, and safer prompts.

Ettore Di Giacinto's LocalAI Platform

How an Italian open-source veteran built a drop-in OpenAI replacement that runs on consumer hardware with no GPU required

Elie Steinbock's Inbox Zero

How the Israeli founder built Inbox Zero, an open-source AI email assistant with plain-English rules that hit #1 on GitHub and won Best AI at FOSS Awards

Dylan Freedman's Local Semantic Search

How the NYT AI Projects Editor built Semantra, an open-source privacy-first tool for searching PDFs and documents by meaning instead of exact keywords

Debug Your RAG Pipeline Before Users Notice

Monitor retrieval-augmented generation systems with OpenTelemetry tracing. Find whether bad answers come from retrieval, context, or generation.

Debanjum Singh's Open Personal AI

How the Khoj founder builds trustworthy AI assistants that search your documents locally

David Soria Parra's Model Context Protocol

How an ex-Facebook engineer frustrated with copy-paste workflows created MCP, now the standard for connecting AI to external tools.

Daniel Miessler treats AI as personal infrastructure

Daniel Miessler's Fabric and Personal AI Infrastructure work shows how AI becomes useful when prompts, context, CLI workflows, and memory are treated as system parts.

Daksh Gupta's Independent Code Review Thesis

Why the Greptile founder believes AI that writes code should never be the same AI that reviews it

Craig Motlin's Autonomous Development Loop

How a Two Sigma VP built a self-running Claude Code system with todo-driven automation and parallel worktrees

Context Rot: When More Tokens Mean Worse Results

LLM performance degrades predictably as context windows fill up. Learn why this happens, how to detect it, and practical strategies to maintain output quality.

Cole Medin: Context Engineering, PRPs, and Archon

Cole Medin's context-engineering workflow for AI coding: write Product Requirements Prompts, front-load examples and validation criteria, then wire the pattern into Archon.

Chris Wiles' Claude Code Showcase Template

A full-stack engineer's comprehensive CLAUDE.md template with skills, agents, hooks, and GitHub Actions

Chris Pedregal's Invisible AI Notepad

The Socratic founder built Granola, an AI meeting notepad with rare 70% weekly retention. His insight: UX execution beats model capabilities.

Brian Christner's Human OS

How a Docker Captain built a unified personal operating system using AI and MCP servers

Brian Casel's Spec-Driven Development

How a serial bootstrapper built Agent OS and Design OS to bring structure to AI-assisted coding workflows

Brandon Redmond's Claude SDK for Rust

A former math teacher built the first community Rust SDK for Claude Code, making type-safe AI agents accessible to systems programmers.

Ariya Hidayat's Anti-Framework Approach to LLM Development

The creator of PhantomJS and Esprima argues against LLM frameworks, showing how to build AI tools with simple API calls instead

Andreas Stuhlmuller's Factored Cognition

How the Elicit founder breaks complex AI reasoning into verifiable subtasks, enabling weaker models to reliably catch errors from stronger ones

Alex Newman's Persistent Memory for Claude Code

How a 20-year web veteran built the most-starred Claude Code plugin by treating AI memory as a compression problem

AI Memory Compression

Techniques for compressing AI observations into retrievable semantic summaries that fit in context windows

Affaan Mustafa's Everything Claude Code

An Anthropic hackathon winner shares 10 months of battle-tested Claude Code configs: agents, skills, hooks, and context management

Addy Osmani's Spec-Driven AI Coding

How Google's Head of Chrome Developer Experience applies structured prompts and specs to get reliable results from coding agents

Adam Azzam's ControlFlow Framework

How Prefect's VP of Product built ControlFlow and Marvin, bringing workflow orchestration and failure handling to AI agents with native observability

Memory Consolidation and Forgetting

How AI agents consolidate short-term observations into long-term storage using sleep-inspired patterns, plus when and what to forget.

The Skills System

Create reusable AI capabilities with Claude Code skills

Tiago Forte's Second Brain + AI

PARA and CODE methods with AI. What works, what doesn't, and where AI actually helps.

Prompt Engineering for Agent Coding

Structure prompts that make AI coding agents 30-40% more effective

CLAUDE.md Best Practices

Write effective project instructions that Claude reads at every conversation start

Preference Learning: AI That Adapts to You

How AI systems infer your preferences from interactions and adapt without configuration. Covers POPI, Mem0, LaMP benchmarks, and building preference-aware systems.

Tool Routing: How AI Agents Pick Which Function to Call

Modern agents route between dozens of tools using semantic matching, LLM-as-router, hierarchical patterns, and fallback chains. Patterns for scoring, selection, and MCP sampling.

Browser agents vs Playwright: when to use AI browser automation

Choose between manual browser work, Playwright scripts, browser agents, Playwright MCP, and hosted browsers. Includes auth rules, receipts, and failure checks.

Riley Goodside's Prompt Engineering Patterns

How the world's first Staff Prompt Engineer approaches LLM interaction as an experimental science

Voice-First Note Capture: Whisper to Structured Markdown

Use whisper.cpp for local transcription, then LLM post-processing to convert rambling voice memos into structured notes with headers, bullet points, and action items

Ali Abdaal turns content into a capture system

Ali Abdaal's AI content workflow is useful as an operating pattern: capture raw thought fast, process it with AI, then keep human taste in the final edit.

Ollama vs vLLM vs llama.cpp vs LM Studio: choose the local runtime by job

Choose a local LLM runtime by workload: Ollama for laptop/dev, llama.cpp for GGUF control, LM Studio for a desktop UI, and vLLM for multi-user serving.

Subagent Patterns: Parallel, Sequential, Background

Three dispatch patterns for delegating work to AI subagents and when to use each one.

Keep Claude Running for Hours

Build autonomous development loops using todo files, hierarchical subagents, and context compaction to process task lists for hours without human input.

Harper Reed's LLM Codegen Workflow

How the former Obama CTO structures AI-assisted development into brainstorm, plan, and execute phases

Multi-Agent Coordination: How to Run Three AI Agents Without Merge Conflicts

The four-phase workflow for running parallel AI agents on the same codebase using tmux, git worktrees, and a shared AGENTS.md file.

Teresa Torres's Claude Code Task System

How the Continuous Discovery author built a personal operating system with Claude Code, Obsidian, and custom slash commands

Boris Cherny: Claude Code, Git Worktrees, and Parallel Agents

How Boris Cherny runs 5+ Claude Code sessions simultaneously: one git worktree per task, less context bleed, automated PR workflows, and a smaller version you can start with two agents.

Multi-Agent Knowledge Management

When a single AI can't handle your PKM needs, specialized agents working together can automate capture, processing, and synthesis.

Build a TIL System That Actually Works

Set up a Today I Learned repo in 10 minutes. Low-friction knowledge capture that compounds into a searchable reference.

Browser Agents

AI that clicks, types, and scrolls your browser autonomously to complete web-based tasks

Matt Shumer's Browser Agent Vision

How the HyperWrite CEO is building AI that operates your browser like self-driving mode for the web

Maggie Appleton turns notes into working terrain

Maggie Appleton shows how public notes become living terrain: mapped, linked, visual, and useful for AI-era design work.

From Chat to Cron: Building Automated PKM Pipelines

Stop manually organizing notes. Build cron-triggered AI workflows that process, tag, and connect your knowledge base on autopilot.

Running Claude Code in Containers

Isolate agent execution with Docker for security, scalability, and 24/7 operation

Model Quantization: Running 70B Models on a Laptop

Reduce model precision from 32-bit to 4-bit to run large language models locally. Covers k-quants, GGUF, and choosing the right quantization level.

Pieter Levels' Solo Business Approach

How Pieter Levels built $3M+/year in solo revenue with AI coding, simple tech, and high failure tolerance.

Human-on-the-Loop

Move from approving every AI action to supervising agents that act autonomously, escalating only when confidence drops or risk rises.

Alex Albert's Claude Mastery

Anthropic's Claude Relations lead shares the prompting patterns that make Claude most effective

llama.cpp setup guide: build, run, and troubleshoot GGUF models locally

Build llama.cpp, load a GGUF model, run the CLI or server, and verify the install with one smoke test and troubleshooting table.

The Architecture of a Personal OS

Personal OS architecture: interface, agent, memory, integration, and tool layers. Build your AI system incrementally in 4 weeks

Checkpointing - Safe Rollback for Agent Work

How automatic checkpoints protect your work and let you recover from agent mistakes

Ethan Mollick's Four Rules for AI in Knowledge Work

Research-backed framework from Wharton professor on when and how to use AI for knowledge work, including the Jagged Frontier concept and practical prompting techniques.

Automated Development Journaling with MCP and CLAUDE.md

Connect Claude Code to your note app via MCP, then use CLAUDE.md instructions to create journals automatically as you work

Artur Piszek's WordPress Personal OS

How a software engineer turned WordPress into a self-hosted personal operating system with AI-ready architecture

Linus Lee's Custom AI Tools

How a tools-for-thought researcher builds personal AI systems from scratch to expand what's possible to think

Late Chunking: Context-Aware Document Splitting for Better Retrieval

Process entire documents through embedding models before splitting to preserve cross-chunk context that traditional chunking destroys

Personal Search: Searching Your Own Data

Build a search engine for your notes, journals, tweets, and memories instead of the web

Task Decomposition for AI Documentation

Break documentation projects into discrete steps to get accurate, consistent output from AI tools instead of hallucinated garbage.

Steve Krouse's Val Town Platform

How the Future of Coding creator built a social platform where AI can deploy JavaScript in 100 milliseconds

Amjad Masad's Replit Vision

How the Replit founder is democratizing software creation with AI-powered coding environments

Nat Eliason's AI Productivity Stack

How the Growth Machine founder evolved from Roam Research to AI-powered systems for goals, writing, and personal knowledge

Auto-Activating Skills in Claude Code

Configure skills to trigger automatically based on keywords, file patterns, and context instead of manual slash commands.

10 AI Agent Failure Modes: Why Agents Break in Production

The documented ways AI agents fail: hallucination cascades, context overflow, tool calling errors, and 7 more. Diagnosis patterns and fixes for each.

Daniel Vassallo's Small Bets: How to Build a Portfolio of Profitable Products

Learn Daniel Vassallo's Small Bets philosophy: how he left a $500K Amazon job to make $1M+ with tiny products by embracing randomness and portfolio thinking.

Malleable Software

Software as clay you reshape, not appliances you consume

Andrej Karpathy's AI-First Development

How Andrej Karpathy builds software in the AI era: vibe coding for prototypes, three-layer workflow for production.

Jesse Vincent's Superpowers Skills Framework

How the Keyboardio founder built an agentic skills methodology that turns Claude Code into a self-steering development system

ACE Framework for Personal AI

Implement David Shapiro's six-layer cognitive architecture to give your Claude Code assistant mission, values, and strategic context

Sahil Lavingia's AI-First Company

How the Gumroad CEO runs a $10M ARR company with AI agents writing 41% of code commits, targeting 80%

MCP Server Composition

Connect your AI agent to multiple MCP servers at once, combining calendar, database, files, and search through one protocol

Building an AI Second Brain

Transform AI from chatbot to persistent knowledge partner

Plan Mode in Claude Code

Research before coding to avoid wrong approaches and hallucinations

Thorsten Ball's Agentic Coding Vision

How the Amp lead at Sourcegraph reconciles skeptical friends and transformative personal experience with AI coding agents

Quick Start: Pick Your Path

Three ways to build a personal OS today. Choose based on your tools and comfort level: Claude Code for developers, GPT + Zapier for quick setup, or Gemini for Google users.

Principles for AI Delegation

What to delegate to AI and what to keep human

Agent Checkpointing: Save, Restore, and Rewind Autonomous Work

How checkpoint systems enable long-running agent workflows by saving state periodically, allowing recovery from failures and rollback from bad decisions

Memory Attribution and Provenance

Track where AI memories came from, when they were created, and how much to trust them

Hybrid Search: Combining Keyword and Semantic Retrieval

Vector search misses exact matches. Keyword search misses concepts. Hybrid search with reciprocal rank fusion combines both for personal knowledge bases.

Geoffrey Litt's Malleable Software Vision

How a researcher at Ink & Switch and Notion is building toward software that users can reshape like clay

Context Window Management

Keep your AI sharp by managing what fits in its working memory

Git Worktrees for Parallel Agents

Run multiple AI agents on the same codebase without conflicts using git worktrees

Alexander Opalic's Claude Code Deep Dives

How a German developer became the go-to source for understanding Claude Code's full stack — MCP, skills, subagents, hooks, and plugins

Custom Slash Commands

Create reusable workflows triggered by /name in Claude Code

Swyx's Learning in Public

Why documenting your learning publicly creates more career opportunities than private study.

Self-Updating Instructions (Procedural Memory)

Build AI agents that modify their own operating instructions based on experience, feedback, and observed failures

Bas Nijholt's Agentic Coding Journey

How a quantum physicist at IonQ went from AI skeptic to shipping packages faster than ever with Claude Code

Claude Code for Non-Developers

How product managers, analysts, and writers use Claude Code without writing a single line of code

Vibe Coding

Building software through conversation instead of keystrokes

Voice-First Content Creation

Replace typing with talking. Brain dump while walking, transcribe with AI, generate multiple versions, polish the best. From 2 hours to 30 minutes per piece.

David Shapiro's ACE Framework

How an AI researcher designed a layered cognitive architecture for building autonomous personal AI systems

Pixel NAS: Turn a 2016 Pixel into a Google Photos Upload Daemon

Use an original Pixel as a tiny always-on inbox that syncs photos from other devices and uploads them to Google Photos.

Peter Yang's AI Content System

How a product lead interviews AI power users and builds systems for content creation at scale

Ado Kukic's Advent of Claude

How Anthropic's Developer Relations engineer documented 31 days of Claude Code tips, from basics to advanced agent patterns

Steve Yegge on Chat-Oriented Programming

How the veteran programmer and Sourcegraph engineer champions AI-first coding and coined CHOP as the new default for developers.

Simon Eskildsen on Learning Infrastructure

How the turbopuffer CEO built personal systems for reading, retention, and knowledge management using Airtable, Anki, and custom tooling.

Hrishi Olickel's Approach to Building Practical AI Tools

How the Southbridge AI founder builds open-source tools and writes actionable guides for working with LLMs in production.

Beyang Liu's Agentic Coding Setup

How the Sourcegraph co-founder uses AI agents to generate 90% of his code while keeping the editor for diff review and diagnostics.

Benjamin Clavié on Making ColBERT Actually Usable

How the creator of RAGatouille bridges information retrieval research and practical RAG systems through open-source tools.

Anton Osika: From Particle Physics to $6B AI Startup

How the gpt-engineer creator built Lovable into Europe's fastest-growing AI coding company with 8M users and $200M ARR.

Matt Rickard's Systems Approach to AI Tools

Former Google engineer applies distributed systems thinking to AI tools: structured output, browser inference, and personal productivity.

Justine Tunney's Local-First AI

The systems hacker behind llamafile wants you to run LLMs like Unix commands—portable, composable, and completely offline.

Flo Crivello's AI Agent Philosophy

How the Lindy.ai founder thinks about building personal AI assistants that handle real work, plus his contrarian takes on solo founding and AGI risk.

Charlie Holtz Builds AI Tools That Spark Joy

Creator of Melty, Narrator, and Conductor shows how rapid prototyping turns AI experiments into viral projects.

Alex MacCaw on AI-Powered Note-Taking

Creator of Reflect Notes builds AI into personal knowledge tools. His vibe coding approach and WorkGPT framework show how senior engineers work with AI.

Tool Use Patterns: How LLMs Call External Tools

Function calling, MCP protocol, and ReAct patterns for AI tool use. Learn when to use each approach and how to implement them.

Chip Huyen's AI Systems Philosophy

How the author of AI Engineering and Designing ML Systems thinks about building production AI, from real-time ML to personal tooling

Proactive AI Agent with Semantic Memory

Turn your AI from reactive chatbot into proactive assistant using heartbeats, semantic search, and persistent memory.

Tom Johnson's AI-Assisted Technical Writing Workflow

How the technical writing veteran uses iterative prompting and task decomposition to double his documentation output at Google

Gregor Zunic's Browser Use Framework

How the ETH Zurich founder built the open-source library that lets AI agents control web browsers like humans do

Simon Willison's Workflow

How the Django co-creator uses CLI tools, SQLite logging, and rapid prototyping to build an AI-powered workflow

The Three-Layer Workflow

Match your AI tool to the task: tab completion for most work, agents for multi-file changes, reasoning for architecture

Armin Ronacher's Agentic Coding Practice

How the Flask creator approaches AI-assisted development with Claude Code — token-efficient, low-intervention, and surprisingly Vim-friendly

Hybrid Retrieval: When RAG Meets Long Context

Combine RAG retrieval with long-context windows strategically instead of treating them as competing approaches

Agentic Design Patterns: ReAct, Reflection, Planning, Tool Use

When to use ReAct loops, self-critique, task decomposition, and tool calling in AI agents. A practical pattern library for building effective agent systems.

Kent C. Dodds' AI-Powered Developer Educator Workflow

How the creator of Testing Library and Epic React uses ChatGPT, Copilot, and Cursor to teach hundreds of thousands of developers

Hooks System in Claude Code

Automate workflows with deterministic triggers that run shell commands at specific points in Claude Code's lifecycle.

Claude Code Plugins System

Extend Claude Code with plugins for custom tools, MCP servers, and workflows

Customizing the Status Line

Configure Claude Code's status line to display model, git status, tokens, and custom information

What is a Personal OS?

A Personal OS is the user's control plane for memory, identity, permissions, tools, workflows, actions, receipts, and rollback across AI agents and devices.

Building Your First MCP Server

Create custom MCP servers to extend Claude with your own tools

Claude Code Setup Guide

Complete Claude Code setup guide: installation, MCP servers, custom CLAUDE.md instructions, shell aliases, and security configuration

Sandboxing & Security for AI Agents

How to isolate AI agents using OS-level sandboxing to prevent unauthorized access and reduce permission fatigue.

Building a Memory System

Build persistent AI memory with Claude Code using episodic-memory MCP, memory files, and external tools like Obsidian and Notion

Graph Memory for Personal AI

Knowledge graphs track relationships between people, projects, and time that vector databases miss. Build AI memory that understands context across sessions.

Episodic Memory for LLM Agents

Give AI agents memory of specific past events with temporal context. The missing piece between semantic facts and procedural rules in the CoALA framework.

Terminal-Native AI Coding: Neovim with Claude Code

Run Claude Code alongside Neovim in split terminal panes. Keep your vim keybindings while getting AI assistance. No VS Code required.

Self-Evolving Agents

Build AI agents that improve through structured feedback capture, automated evaluation, and continuous retraining loops

Agent Observability

How to implement distributed tracing, logging, and monitoring for AI agents using OpenTelemetry and purpose-built tools like Langfuse and Braintrust.

Agent Guardrails: Input/Output Validation for Autonomous Systems

How to implement runtime guardrails that validate agent inputs, filter outputs, and enforce business rules. Covers NeMo Guardrails, layered checking, and production patterns.