Building With AI
I build with AI in public: agents, automations, and web systems, shipped and documented, including the pipeline that writes this site. This hub is the running log. Not tutorials in the abstract, but what actually worked, what broke, and the boring infrastructure that decided the outcome. The through-line: shipping with AI is less about the model and more about the plumbing, the taste, and the willingness to cut what isn't working. If you'd rather see the receipts than the highlight reel, start here.
236 posts
Recent articles (30)
- Amplitude's Wave and the agent loop that starts before anyone asks for a feature OpenAI says Amplitude's Wave agent finds what to build, drafts the change, and measures the result in days, a full-loop pattern that most teams still run as four disconnected jobs with humans stitching the gaps.
- Fine-tuning 3D generation models is an asset pipeline problem Hugging Face’s 3D generation fine-tuning guide points to a practical shift: the win is not generic text-to-3D magic, but repeatable asset production for specific styles, object classes, and downstream workflows.
- LLMON puts markup closer to the model Hugging Face’s LLMON announcement points to a practical shift: instead of forcing LLMs to imitate human document formats, builders may get better results from formats designed for model attention, parsing, and workflow reliability.
- What Holiday Extras actually shipped with Codex OpenAI says travel company Holiday Extras is building more with Codex, but the case study is thin on numbers. Here is what an operator should read into a coding-agent story like this one, and what to measure before you believe the conversion claims.
- Apple’s rumored local AI app is really a packaging test Reports of an Apple Mac app for running local AI models are thin, but the useful question is clear: can Apple make local inference boring enough for normal Mac users, not just LocalLLaMA regulars?
- ReTrace turns repeatable agents into code paths ReTrace points to a practical middle ground for business automation: use an LLM agent to discover the workflow, then compile its traces into cheaper, faster code that handles repeat runs without planning every step.
- Agent memory is architecture, not a chat history The useful way to think about agent memory is not as one database or longer context window, but as a set of separate systems with different jobs, failure modes, and product choices.
- Claude Code's 'Don't Ask Again' and the 1,122-file password leak A convenience toggle in Claude Code appears tied to credentials showing up in over a thousand public GitHub files, and it exposes a design tension every coding agent now shares between frictionless approval and accidental secret exposure.
- Local AI on 16GB VRAM is a scope problem, not just a model problem A r/LocalLLaMA thread about running useful local agents on 16GB VRAM gets at the real bottleneck: local AI can work, but only when the workflow is narrow, testable, and built around tools instead of vague autonomy.
- What Changes When You Treat an LLM as a Pair, Not a Vending Machine A developer's switch from Claude to Pi sparked a debate about how we actually work with coding models: as autonomous order-takers or as collaborators you argue with. The distinction matters more than the model choice.
- Local GUI agents need disposable desktops, not prettier demos A LocalLLaMA report on Open WebUI and Open Terminal points to the useful part of computer-use agents: local models driving observable, sandboxed desktops that humans can interrupt, inspect, and reset.
- Payment Skimming Hits Restaurant Delivery: What the Campaign Tells Us About AI-Era Web Security A payment-skimming campaign targeting restaurant delivery sites is a reminder that checkout pages leak card data through third-party scripts, and the AI tooling teams now use to build sites can make the problem worse before it makes it better.
- What 'AI accelerating AI research' actually looks like inside a lab A look at the claim that AI is speeding up AI research itself, what the concrete workflows are, where the compounding story holds up, and where it quietly breaks down for anyone trying to apply it to their own work.
- Gemini Is Moving Closer to Google Business Profiles Google’s Gemini Business Profile tools are reportedly coming to Workspace accounts, a small product change that matters because local marketing work is moving from dashboards into assistant-driven workflows.
- What Anthropic's SDK Error Codes Tell You About Running Claude in Production Two quiet releases of the Anthropic Python SDK add structured error codes, thread-safe parsing, and path-injection guards. Here is what those changes mean for anyone running Claude agents at scale, and why error handling is where agent reliability actually lives.
- What Changed in OpenAI's Images 2.6 for People Who Actually Ship OpenAI's Images 2.6 adds GIF generation, reference images, and a claimed 50% speed bump on two new API models. Here is what that means for builders shipping image workflows, and the details OpenAI has not nailed down yet.
- Cognitive symbionts shift the agent question back to the human The arXiv paper on cognitive symbionts makes a useful distinction: the next agent frontier may not be more autonomy, but better augmentation of one person’s memory, attention, context, and decisions over time.
- OpenAI’s Pando points to the next bottleneck for coding agents OpenAI built Pando, a Git-compatible backend, because agent-heavy development changes the pressure on source control. The interesting lesson is not about Git replacement. It is about what breaks when many more code changes become cheap to create.
- Context is the missing layer in AI code review OpenAI’s Qodo and Codex note points at a practical shift in developer tools: AI review is less about spotting isolated syntax issues and more about applying repository context, team standards, and cross-codebase risk before a pull request exists.
- LangChain’s Python 3.10 cutoff is a maintenance warning for agent stacks LangChain 1.4.8 and langchain-core 1.7.4 are small releases, but the Python 3.10 deprecation matters if your agent stack sits on old runtimes, pinned dependencies, or managed notebooks.
- LifeVal puts AI evals closer to real paperwork OpenAI’s LifeVal points at a better kind of AI benchmark: not whether a model can answer a test question, but whether it can help with messy, high-friction tasks like childcare, finances, and government forms.
- Local AI is becoming the quiet default for private workflows Running open-weight models on your own machine is not mainly about beating frontier chatbots. It is about privacy, offline access, cost control, and turning small repeatable tasks into local workflows you actually own.
- Merged ChatGPT and Codex limits would make usage the real product boundary A thin Hacker News signal about ChatGPT and Codex usage limits points to a practical issue for builders: coding agents and chat assistants may increasingly compete for the same quota, budget, and operational planning.
- What JavaScript Frameworks Cost You When the Reader Is an AI Client-side rendering saves developer effort but hands AI crawlers a blank page, and as agents become a real slice of traffic, the framework choice you made for humans now quietly taxes every bot that visits.
- Unlimited AI Tokens Are a Process Test, Not a Coding Strategy A Hacker News item says Cisco gave an engineer unlimited AI tokens to rewrite legacy code. The interesting part is not the token budget. It is whether the team has enough tests, ownership, and review discipline to make AI-assisted rewrites safe.
- Chrome’s Gmail Autofill Is Small, Useful, and Privacy-Sensitive Decrypt reports that Chrome can use Gemini to pull order, tracking, and flight details from Gmail into web forms. The useful part is obvious. The hard part is trust, consent, and knowing when convenience becomes ambient account access.
- LangChain’s tiny core releases are really about state discipline LangChain core 1.7.2 and 1.7.3 are small releases, but the interesting signal is practical: agent frameworks now need tighter rules for message state, metadata, and upgrade hygiene.
- Granite Switch pushes model updates toward software discipline Hugging Face’s Granite Switch framing matters less as a single model release and more as a pressure test for AI operations: if models are going to update like software, teams need versioning, eval gates, rollback plans, and boring release hygiene.
- Hugging Face points open AI back at the iPhone Hugging Face’s AnySpeechRecognizer and AnyDecisionModel announcement is less about one model drop and more about a practical shift: open models that run close to users, on Apple hardware, for speech input and local decision workflows.
- Mistral Large 4 lands where builders actually test models Hugging Face’s announcement puts Mistral Large 4 into the model marketplace builders already use, but the real question is not launch-day hype. It is whether teams can compare it cleanly against their own workloads, costs, and failure cases.
Earlier articles (205)
- OpenAI and ServiceNow move agents closer to enterprise work queues
- What OpenAI's Ropes & Gray diligence build actually automates
- What OpenAI's Updated Model Spec Actually Changes for Builders
- Hidden AI Opinions Can Steer Expert Analysts
- Voice-first rehearsal is a better AI workflow than slide generation
- DexPort makes robot hand data collection less robotic
- Inbox agents need labels before models
- AI payoff outside tech is a workflow problem, not a model problem
- AI prose gets hard to read when it removes friction
- The wrong way to count AI job losses in media
- AI enablement is becoming curriculum ops
- Claude Duet tests the proactive assistant, not a new chatbot
- OpenAI’s Dots demo turns bug triage into an agent workflow
- RealPage’s AI training workflow is the useful kind of boring
- The air purifier lesson for AI products
- What Anthropic's SDK Changelog Says About Claude's Enterprise Push
- AI makes weak marketing dashboards fail faster
- Claude Code turns smart TV cleanup into a weekend mod
- OpenAI’s Google Cloud Move Is About Distribution, Not Model Drama
- SERP network data is becoming an SEO research surface
- DeepSeek’s developer search move makes authority scoring part of the product
- Legal AI trust starts with workflow, not model magic
- TorchNeuron points at the real Trainium bottleneck: developer friction
- Sphinx turns AI code shipping into a comprehension check
- The Opencode breach report is a key-rotation drill
- Themeable Mermaid SVGs solve a small but real AI docs problem
- What OpenAI's 'ultrafast' service tier for Agents actually signals
- LangChain 1.6.12 fixes a small streaming metadata leak
- LeanGraphSearch makes theorem provers follow the proof graph
- Reading OpenAI's SDK Changelog: Caching, Voice Cloning, and the Mystery of 'Decisions'
- StepFun’s agent phone is a bet against the app grid
- Agreement review is where legal AI gets real
- Google DeepMind’s audit separates code volume from research speed
- The Case for Making Research Agents Forget Their History
- PDFs can rank, but they are still a weak default for SEO
- Self-Evolving Agent Harnesses Need Change Control More Than Hype
- Tool retrieval should know when the tool is broken
- Build a Decision Model Before You Automate the Decision
- Oracle’s Codex story is about killing the report backlog
- README testing is cheap agent evaluation for humans
- What ExxonMobil's Deception Case Teaches AI Builders About Source Trust
- What the openai-python v3.29.0 changelog tells you about the API roadmap
- LLMs belong in the feature factory, not always in production
- OnTrack watches agent trajectories before the bill is paid
- Asana’s browser-agent test points to the real AI cost story
- GPU scheduling is where AI infrastructure gets real
- LegalOn’s Codex cost cut was routing, not magic
- What Sophos actually automated to cut threat response from 38 minutes to 89 seconds
- GPT-6 and Intelligent UI: What OpenAI Actually Announced
- AI is better as the SEO audit explainer than the SEO auditor
- AI compresses the domain-to-website workflow
- Agent memory is not a substitute for readable docs
- Opus 5.5 tips are really workflow design tips
- SaaS Is Becoming the Control Layer Around Models
- When an Agent Reports Success and the Database Says Otherwise
- A simulated canvas turns vision models into operators
- Chainalysis’s AI tracing claim is a workflow story, not magic attribution
- Claude Design and the Return of the Design Spike
- LLM security starts where code enters the pipeline
- Local LLM runners are becoming product choices, not hobby projects
- Karpathy’s Aircraft Manual Prompt Is Really a Spec for Better AI Output
- OpenAI’s Python SDK is getting more agent-shaped
- MatLoom makes generated materials editable, not just pretty
- MAICON’s Real-Time Podcast Move Is a Content Ops Signal
- The Harness Is the Model: What 'Meta-Skills for Agent Harness Design' Actually Shows
- OpenAI's DevDay agents move the product boundary from chat to operating system
- Black-box attribute alignment is a sampler, not a fairness wand
- Leaves.com shows the new domain decision: sell the name or ship the site
- The useful part of Roetzer’s architect-orchestrator-apprentice AI work model
- When Documentation Doesn't Help Coding Agents: A Negative Result Worth Reading
- Agent control failures are moving from demo risk to operating risk
- Drawgent puts a coding agent on an Excalidraw canvas: what a visual work surface actually changes
- Keeping programming enjoyable when LLMs write the first draft
- Qwen 27B on a 4090 is a useful reminder about local AI demos
- Claude Code’s verification loop is the real coding-agent primitive
- Ollaya points at a missing layer for decision models
- What One Developer Learned From a Month Without AI Tools
- When Agents Hack: What the OpenAI-Hugging Face Story Actually Tells Builders
- AI Agents Make Audience Data Debt More Expensive
- CliffCompaction makes long coding runs cheaper by refusing to summarize
- Local tool-use evals are measuring your server too
- OpenAI’s Python SDK adds model handles before the launch story
- Jev shows why science workflows need semantic evals, not just final-answer grading
- AI adoption is the easy checkbox. Workflow adaptation is the actual job
- AI writing is useful until it starts doing your thinking
- AI posters get better when the model stops being the designer
- Hex, GPT-6 Astra, and the shift from answers to visual reports
- LangChain 1.4.2 fixes a small but real agent reliability problem
- Laya’s Jev claim needs a repo-first reality check
- What Two Boring openai-python Patches Reveal About Agent Reliability
- Jev is a decision model, not another chatbot
- LangChain’s typesafe alpha points at safer model routing
- The Harness Matters as Much as the Model in Coding Agents
- Claude as a transfer-code assistant for domain portfolios
- CareMirror puts caregiver consent at the center of dementia AI
- Slip Detection Is Where Robot Hands Stop Dropping Things
- The Skill Router You Already Have: Gavel Reads Routing From a Frozen LLM
- A vulnerability is not fixed because an AI bot saw it
- JPEG XL Is a Workflow Question, Not a Format War
- Turn repeat marketing work into tools, not just prompts
- What Fyxer's AI inbox assistant gets right about trust
- What llama.cpp v0.4.1 tells you about where local AI is heading
- Real-SWE and the Case for Testing Coding Agents on Code They Have Never Seen
- A Filter That Strips AI Stories From Hacker News, and What It Reveals
- AI sadness is product feedback, not just backlash
- Devin testing its own work with GPT-6 Astra: what's real, what's reported
- Rune going open source is only the start of the diligence
- The RubyGems agent report is a supply-chain warning
- The useful part of a smaller LLM gateway is not the size
- Conversational XAI works best when it is a control surface, not a chatbot
- The marketing AI stack is too full now
- Codex as a lab scout for antimicrobial search
- PPC Automation Needs Guardrails, Not Blind Trust
- Browser agents are becoming practical comment analysts
- OpenAI’s Python SDK gets key expiration controls, not just new image hooks
- Pick the hospital automation work before picking the bot
- Procedural Graphs give agents a memory of what to do, not just what happened
- What ChatGPT Images 2.5 Changes for People Who Actually Ship Images
- AI Made the First Draft Free. The Bottleneck Moved Downstream.
- OpenAI’s journalism program stretches from classrooms to newsrooms
- OpenAI's Python SDK Gets More Honest About Agent Failures
- Agent Harnesses Are Becoming a Token Efficiency Fight
- Local LLMs as the first responder for a compromised PC
- The useful part of calling LLMs a cognitive virus
- The real lesson in a 90% Claude Code token cut
- What LangChain Core 1.6.2 Fixes for Agent Builders
- Repo-distilled skills are the missing middle layer for research agents
- ACToR targets the tokens where repo-level code generation breaks
- AI workflows should create new work, not just faster tasks
- Culture Still Sets the Ceiling on AI Productivity
- No AI Fridays: What a Weekly Ban Reveals About Skill Atrophy
- When LLM memory becomes program analysis
- MCR-Bench shows code review agents still lose the plot
- Anthropic’s Python SDK is tightening the agent plumbing
- Gemini Omni 1.1 Flash needs to prove control, not just speed
- Codex at loveholidays points to the real no-code shift
- OpenAI’s full-stack argument is really an economics argument
- Prime Agent treats the harness as part of the model
- Compliance LLMs need different workflows for passports and DPIAs
- Codex over Claude is a workflow signal, not a verdict
- Munder Difflin and the real work behind AI clone offices
- Claudette and the fight against AI house style
- What LangChain's perplexity 1.4.1 patch says about agent plumbing
- AI literacy is the new fault line: what OpenAI's CodeAI deal actually signals
- Gemini 3.7 Flash and the New Floor for Cheap Models
- AI coding feels like managing a very literal junior engineer
- Alzheimer’s surgery claims need evidence before amplification
- A one-line Hacker News item is not enough context
- What Actually Makes a Claude Code Session Productive
- What OpenAI's v3.1.0 SDK Changelog Tells Us About Its Roadmap
- OlmoEarth embeddings are useful if they survive outside the studio
- RingCentral’s AI-native work story is really about the handoff
- VICBench shows vulnerability detection still needs humans
- AI security review is hitting Bitcoin repos, not just toy code
- Claude’s Bluetooth hint is the right kind of AI assistance
- AI coding cost control is an engineering workflow problem
- Kitesurf and the browser built for agents, not humans
- LLMs as semantic scouts for compiler optimizations
- OpenAI’s education plugins move ChatGPT closer to classroom workflow
- The Financial Advice Chatbots Give You Depends on the Question You Bring
- AI reasoning can look right while taking shortcuts
- Flint points at a missing layer in AI visualization
- Go’s generic collections proposal is really about shared defaults
- The useful question behind a multiplayer agent harness
- RL can teach code models to care about runtime, but the stopwatch is the hard part
- Brolly’s plain-text weather page is an AI product lesson
- Half-Life 2 on HaikuOS and the AI runtime tax
- LangChain’s xAI update is really about model contracts
- OpenAI’s small business push is really a workflow bet
- Stack Overflow’s AI problem is the missing feedback loop
- ChatGPT’s computer control turns the browser into the new agent runtime
- Open AI is a stack problem, not a license argument
- Shopify’s agent lesson is delegation, not autonomy
- Virgin Atlantic’s ChatGPT story is really about workflow compression
- Grok Build’s Apache 2.0 release puts the boring work on users
- New model releases do not reset the advantage
- Claude for Teachers is really a feedback-loop product
- ChatGPT onboarding starts with a real task, not a perfect prompt
- “Ask an LLM” Is Not an Answer to Every Question
- Intelligence Is Still Not the Product
- Same-prompt app builds are useful, but not enough
- Leanstral 1.5 points at proofs as a workflow, not a stunt
- TPG’s ChatGPT rollout targets the boring costs of diligence
- Timestamp drift is the quiet ASR failure that breaks real workflows
- A GPT-5.6 rumor matters only if Codex changes with it
- An aviation headline in the AI feed is a pipeline problem
- Agentic coding works best when the repo has rails
- The Model Got Smarter and My Tool Got Dumber
- Buccy Bench makes model progress look usefully stupid
- Code-as-image is a cost hack, not a free lunch
- Local LLMs are becoming a workflow choice, not a hobby project
- Anthropic’s Python SDK points to agents as infrastructure, not demos
- Hermes Agent moves the agent demo into the payments layer
- Hermes turns agent setup into packaging work
- Local AI is insurance, not a bunker
- CUGA's Two Dozen Examples Are the Real Agent Documentation
- What llama.cpp's commit log tells us about AI-written code
- Entity gap patching: the pSEO maintenance loop most teams skip
- Cursor is the spreadsheet moment for marketing ops
- Replacing the gated PDF with a working tool built in an afternoon
- Marketers are still vibe-checking prompts. Frontier devs run evals before lunch.
- Stop Vibe-Checking New Models. Build a 50-Prompt Eval Set Instead.
- The mechanism matters: making AI competitive analysis auditable
- Why I Stopped Trusting My Own Prompts (And Started Logging Them)
- Why I Stopped Trusting AI Demos and Started Timing My Own Workflows