Thoughts on AI Safety
A cautious, nuanced case for AI optimism: why safety, interpretability, bias, and alignment matter as much as raw capability.
Steve Kinney
Steve Kinney is a software engineer, educator, and engineering leader in Denver, Colorado, with deep experience in AI systems, developer tools, and frontend architecture.
Latest posts
Using Codex from Claude: Getting a Second Opinion from a Different Model Family
I wired OpenAI's Codex into Claude Code as a consulting subagent—a different training lineage I can tap for architecture calls, stuck bugs, and security reviews. Here's how the `codex-advisor` agent works and why it isn't actually an MCP server anymore.
Multi-Model Agentic Coding: Letting the Other Model Do the Typing
The follow-up to my Codex-as-advisor setup. Same second model family, opposite stance: instead of asking Codex for an opinion, I hand it the implementation, let it work in an isolated worktree, and run an approval loop where I own the diff and Codex never gets to commit.
Sentinels: The Quiet Power of a Touched File
How I use sentinel files to gate the risky moves my coding agents make—exiting plan mode, opening a pull request, addressing review feedback, backing off a rate-limited model. The whole mechanism is a file on disk and a hook that checks for it.
Claude Ultraplan: Planning in the Cloud, Executing Wherever
Ultraplan hands the planning phase of a coding task off to a Claude Code on the web session running in plan mode, then lets you review it in the browser and decide where to execute. Here's what it actually changes about your workflow, what it costs, and where the sharp edges are.
Playwright vs. Chrome DevTools MCP: Driving vs. Debugging
Playwright and Chrome DevTools both ship official tools for letting AI agents drive a browser, but they're optimized for different jobs. Here's how Playwright CLI, Playwright MCP, and Chrome DevTools MCP actually fit together, and how to pick between them without guessing.
Entering the Mind of Ralph Wiggum
A while-true loop, a prompt file, and a clean context window on every iteration. The Ralph Loop is the dumbest-sounding technique that actually works—and the reason it works will change how you think about programming LLMs.
Memory Systems for AI Agents: What the Research Says and What You Can Actually Build
The old short-term/long-term taxonomy doesn't capture what modern agent memory systems actually do. A new three-axis framework—Forms, Functions, and Dynamics—maps the design space from flat vector stores to RL-driven memory management. Here's what the research says and what you can build today.
Temporal's Developer Skill Is a Promising First Draft
Temporal shipped one of the first major infrastructure vendor agent skills. The diagnosis is right and the architecture is sound. The execution has some fixable gaps.
The Anatomy of an Agent Loop
Every major AI agent runs the same core loop. The 6-line version is easy. The production-hardened version—with context compaction, loop detection, cost budgets, and graceful termination—is where things get interesting.
Agent Skills, Stripped of Hype
Agent skills are not a new capability—they're a context management strategy. Their value comes from routing and progressive disclosure, not from smarter prompts.
Designing a Build System That Runs Untrusted Code
A deep technical walkthrough of what it takes to design a build system that securely executes arbitrary customer repositories and turns build output into deployable artifacts—covering the pipeline, the security model, the architecture, and the operational realities.
Designing an AI Gateway and Durable Workflow System
A two-layer architecture for production AI systems: a gateway that abstracts providers, enforces policies, and tracks costs, paired with a durable workflow engine that makes long-running agentic tasks survive failures, pause for human approval, and replay deterministically.
MCP Apps and the Missing Middle of AI Tooling
MCP servers return data. MCP Apps let them ship a UI alongside that data—so the tool author, not the client, decides how results look.
My Ridiculous AI-Assisted Development Workflow
A walkthrough of the system I use to ship code with AI agents—from planning in Linear to worktrees, linting gauntlets, and a small army of code review bots.
build-temporal-workflow: Faster Temporal Workflow Bundling with esbuild
A drop-in replacement for @temporalio/worker's bundleWorkflowCode that swaps Webpack for esbuild—delivering 9–11x faster builds and 94% less memory usage.
Prompt Engineering Across the OpenAI, Anthropic, and Gemini APIs
A practical guide to writing reliable prompts across the major LLM APIs—covering core techniques, where the providers actually diverge, trust boundaries, and two production workflows built from brittle to hardened.
Introducing Prose Writer
A little TypeScript library for building Markdown-friendly strings without template literal sprawl.
Cursor Rules for Writing Temporal Workflows with TypeScript
Essential guidelines and best practices for writing reliable Temporal workflows in TypeScript, covering serialization, determinism, and workflow patterns.
Cursor Rules for TypeScript Engineers
A collection of some potentially useful Cursor rules as well as a rundown of what potentially makes a Cursor rule great.
Using Anthropic's Message Batches API with Temporal
Build scalable, cost-efficient AI processing with Anthropic's Message Batches API and Temporal workflows.
What If It Goes Wrong?: The Hidden Dangers of Counterfactual Reasoning in AI
Exploring the pitfalls of counterfactual reasoning in AI, highlighting its fragility, chaotic nature, and alignment with Nassim Taleb's critique of prediction in complex systems.
Getting the Most Out of GPT-4.1
A naïve guide to get the most out of GPT-4.1: context window optimization, coding tips, prompt best practices, and when to choose GPT-4.1 over GPT-4.5.
Neural Networks
A friendly intro to neural networks, what they are, how they learn, and why they matter for software engineers exploring the world of generative AI.
A Gentle Introduction to Using a Vector Database
In which we learn how to build a simple vector database using Pinecone and OpenAI embeddings, and discover it was way easier than we might have expected.
Setting Up a Python Environment on macOS
A brief guide for getting started writing Python on a Mac using virtual environments.
Implementing Obsidian's Callout in Svelte
A gentle walkthrough where we build our take on Obsidian's callout component in Svelte.
Positives, Negatives, and Alternatives to Using Tailwind for a Design System
Is Tailwind the best choice when building out a design system? It depends.
Creating a Markdown Preprocessor for Svelte
Let's look at how to write our own preprocessor for SvelteKit.
Understanding Generics in TypeScript
Let's learn a little bit about what generics are in TypeScript, why they're useful, and how to use them.
A Gentle Introduction to Svelte Stores
Svelte stores simplify state management across components. Let's learn how they're implemented.