# Blake Crosley - Complete Profile

> Designer, developer, and entrepreneur creating meaningful digital experiences that spark joy. Former VP of Product Design at ZipRecruiter. Founder of 941 Apps.

This is the comprehensive version. For a summary, see: [llms.txt](https://blakecrosley.com/llms.txt)

## Professional Summary

Blake Crosley is a product design leader and full-stack developer with over a decade of experience shaping design strategies at major companies and building products used by millions. Based in Pasadena, CA, Blake runs [941 Apps](https://941apps.com), a branding and development studio specializing in iOS applications and design consulting.

## Career Highlights

### ZipRecruiter (12 Years)
- **Role**: VP of Product Design
- **Journey**: Joined when company was ~10 people, grew to NYSE-listed company
- **Team**: Built and led team of 35+ designers
- **Impact**: Shaped product design strategy through company's entire growth arc

### Trailer Park
- Design leadership role
- Collaborations with Apple, Disney, Marvel
- Creative direction for major entertainment brands

### Other Collaborations
- Instacart
- Penguin Random House
- HarperCollins

## Skills & Expertise

### Product & Strategy
- Product design and strategy
- Design thinking methodology
- Design systems architecture
- User research and testing
- Team leadership and mentoring

### Design & Branding
- Visual design and branding
- Logo and identity design
- Design-led transformation
- Design system creation

### Engineering

**iOS/Mobile**:
- SwiftUI (iOS 26+ patterns)
- SwiftData persistence
- HealthKit, StoreKit
- Apple Watch, Apple TV

**Backend**:
- FastAPI (Python)
- SQLAlchemy 2.0+
- Pydantic v2
- Async patterns

**Frontend**:
- HTMX
- Alpine.js
- Bootstrap 5
- Plain CSS (no Tailwind)

### Emerging Technologies
- LLM integration
- Prompt engineering
- AI-driven product design
- Web performance optimization

## Featured Work

### 941 Reps
Fast, private workout log for iPhone, iPad, and Apple Watch, shipped July 2026. Handwritten notebook design (Bradley Hand on near-black), locked days that keep history honest, seventeen languages, and a CLI + MCP connector: agents read a synced replica read-only while every write passes the app's own validation and returns a receipt.
- URL: [https://blakecrosley.com/work/reps](https://blakecrosley.com/work/reps)

### Vision Sprint (ZipRecruiter)
Exploration of the future of work, removing traditional job search paradigms. Led as VP of Product Design, exploring how LLMs could transform job discovery.
- URL: [https://blakecrosley.com/work/vision-sprint](https://blakecrosley.com/work/vision-sprint)

### Project eLLMo (ZipRecruiter)
LLM-based job preference discovery system addressing the 50% of users who arrive without specific job titles. Co-led across product, design, and data science teams. Used 1,397-token base prompt through extensive experimentation.
- URL: [https://blakecrosley.com/work/ellmo](https://blakecrosley.com/work/ellmo)

### Ace Citizenship (941 Apps)
iOS app helping immigrants prepare for USCIS naturalization test. Single-developer project: designed, branded, and engineered by Blake. His most personally meaningful shipped product.
- URL: [https://blakecrosley.com/work/ace-citizenship](https://blakecrosley.com/work/ace-citizenship)
- App Store: [apps.apple.com/us/app/ace-citizenship/id6478826605](https://apps.apple.com/us/app/ace-citizenship/id6478826605)

### Introl Branding
GPU cluster company rebrand. Logo redesign focusing on legibility and symbolism to convey "fast, efficient, well-established" positioning.
- URL: [https://blakecrosley.com/work/introl](https://blakecrosley.com/work/introl)

### Tappy Color
iOS game created in 2016 by Chris Greer and Blake Crosley. A colorful tap game featuring a fish named Tappy that you save by tapping the screen to lift the water line. Now available as Tappy Color Remastered on the App Store. Represents Blake's early game development work.
- URL: [https://blakecrosley.com/work/tappy-color](https://blakecrosley.com/work/tappy-color)
- App Store: [apps.apple.com/us/app/tappy-color-remastered/id6581480913](https://apps.apple.com/us/app/tappy-color-remastered/id6581480913)

### blakecrosley.com
Personal portfolio achieving perfect Lighthouse 100 score. Deep performance optimization reducing CLS from 0.493 to 0.033, LCP from 2.6s to 0.8s.

## Technical Guides

### Claude Code CLI: The Complete Guide — Hooks, MCP, Skills
The complete Claude Code guide: configuration, permissions, hooks, MCP, and subagents, plus the settings and commands that change how it actually works.
- URL: [https://blakecrosley.com/guides/claude-code](https://blakecrosley.com/guides/claude-code)

### Building iOS Apps with AI Agents: The Practitioner's Guide
Build iOS apps faster with AI agents. Claude Code, Codex CLI, Xcode 26.3 native, MCP, CLAUDE.md patterns, hooks, lessons from 8 apps.
- URL: [https://blakecrosley.com/guides/ios-agent-development](https://blakecrosley.com/guides/ios-agent-development)

### Midjourney 8.1 Guide: Prompts, Omni Reference & Parameters
Midjourney 8.1 prompt guide: Omni Reference (--oref), --hd and --sd, --raw, V7 compatibility, video costs, and every parameter that changed — with working examples.
- URL: [https://blakecrosley.com/guides/midjourney](https://blakecrosley.com/guides/midjourney)

### Suno Guide: Tags, Meta Tags & Prompts (V5.5)
Every Suno tag and meta tag that works in V5.5: style prompts, structure tags, [no vocals], the style-of-music field, and MILO-1080 — with copy-paste examples.
- URL: [https://blakecrosley.com/guides/suno](https://blakecrosley.com/guides/suno)

### FastAPI + HTMX: The No-Build Full-Stack
Build production web apps without React or webpack: FastAPI, HTMX, Alpine.js, Jinja2, plain CSS, Bootstrap patterns, i18n, deployment, SEO and performance.
- URL: [https://blakecrosley.com/guides/fastapi-htmx](https://blakecrosley.com/guides/fastapi-htmx)

### Obsidian MCP Guide: AI Search & Retrieval (2026)
Wire Obsidian into Claude and other agents over MCP: server setup, hybrid BM25 + vector retrieval, and indexing a 16,894-file vault — with working configs.
- URL: [https://blakecrosley.com/guides/obsidian](https://blakecrosley.com/guides/obsidian)

### Mac Shortcuts Automation: The Practitioner's Reference
Apple Shortcuts on macOS: the actions catalog, automation triggers, the shortcuts CLI, signing, App Intents, and running shortcuts from scripts and agents.
- URL: [https://blakecrosley.com/guides/shortcuts](https://blakecrosley.com/guides/shortcuts)

### Agent Architecture: Building AI-Powered Development Harnesses
The complete system for building production AI agent harnesses. Skills, hooks, memory, subagents, multi-agent orchestration, and the patterns that make AI coding agents reliable infrastructure.
- URL: [https://blakecrosley.com/guides/agent-architecture](https://blakecrosley.com/guides/agent-architecture)

### Codex CLI Guide 2026: Setup, Sandbox, AGENTS.md & MCP
Complete Codex CLI reference: install and auth, models and pricing, sandbox and approval modes, AGENTS.md, MCP, skills, and cloud tasks. Updated for v0.144.0.
- URL: [https://blakecrosley.com/guides/codex](https://blakecrosley.com/guides/codex)

### Design Principles for Software Engineers
Design fundamentals for software engineers: typography, color, spacing, animation, AI interface patterns, design tokens, and 48 product case studies today.
- URL: [https://blakecrosley.com/guides/design](https://blakecrosley.com/guides/design)

### Hermes Agent: The Practitioner's Reference (2026)
A practitioner's reference to Hermes Agent, the open-source self-improving AI agent from Nous Research: provider auth and OAuth, the config files, the skills system, and running it as a multi-platform messaging gateway.
- URL: [https://blakecrosley.com/guides/hermes](https://blakecrosley.com/guides/hermes)

### Claude Code Cheat Sheet 2026: Shortcuts, Commands & Flags
Fast-lookup Claude Code cheat sheet updated for v2.1.205 — CLI flags, slash commands, keyboard shortcuts, permission modes (Manual rename), models (Sonnet 5 default), hooks, plugins, Agent View, Workflow, and env vars.
- URL: [https://blakecrosley.com/guides/claude-code-cheatsheet](https://blakecrosley.com/guides/claude-code-cheatsheet)

## Blog

Interactive demonstrations and technical explorations:

- [The Robots Are Taking Exams in My Search Console](https://blakecrosley.com/blog/robots-taking-exams-search-console): First-party GSC data: 91% of 3.8M impressions fail a human-query filter. Exam questions, pasted errors, and agent sweeps are rewriting what Search Console means.
- [The Assistants Are the Audience Now](https://blakecrosley.com/blog/assistants-are-the-audience): First-party edge data: AI assistants request my pages ~66x more often than humans visit, and most of it is live user-directed fetching, not training crawls.
- [The Shader Gallery That Lied: Debugging 216 WebGL Presets](https://blakecrosley.com/blog/the-shader-gallery-that-lied): A user said the shader playground looked broken. Pixel-readback testing found 30 dead presets, 11 that never compiled, and the fallback that hid it all.
- [Context Compaction Is Becoming a Training Objective](https://blakecrosley.com/blog/context-compaction-training-objective): Context compaction is moving from an inference-time patch operators babysit to a training-time objective models optimize. CompactionRL is the signal.
- [The Agent Stack Has a 1998 Problem](https://blakecrosley.com/blog/agent-stack-1998-problem): A cluster of agent-tool CVEs in mid-2026 is not bad luck. It is the structural signature of an AI agent ecosystem shipping at 1998-era security maturity.
- [Agents Want to Compile](https://blakecrosley.com/blog/agents-want-to-compile): The agent stack is separating deciding from executing: models compile intent into replayable workflow scripts and DAGs, and deterministic runtimes run them.
- [The Check Becomes the Spec](https://blakecrosley.com/blog/check-becomes-the-spec): Coding agents building to the test: near-perfect oracle scores, dead library shipped. What your checks omit stops being the job.
- [Design Philosophy: Massimo Vignelli — Design Is One](https://blakecrosley.com/blog/design-philosophy-massimo-vignelli): Massimo Vignelli mapped the New York subway in 45-degree angles and beige water, and ran a career on four typefaces. One discipline at every scale.
- [Design Philosophy: Naoto Fukasawa — Without Thought](https://blakecrosley.com/blog/design-philosophy-naoto-fukasawa): Naoto Fukasawa hung a CD player on the wall and gave it a ventilation fan's pull cord. No manual, no learning curve -- design dissolving into behavior.
- [Recreating MacPaint in the Browser: The 1984 Source Code Is the Spec](https://blakecrosley.com/blog/pixelpaint-macpaint-recreation): I rebuilt MacPaint 1.3 in the browser and checked every tool against Bill Atkinson's released Pascal source. What faithful software recreation takes.
- [Claude Code Hooks Explained: The Deterministic Layer Around Your Agent](https://blakecrosley.com/blog/claude-code-hooks-explained): Claude Code hooks run shell commands at lifecycle events — guaranteed. Every event, exit-code semantics, and five patterns from Prettier to a Stop gate.
- [Agents Supersede the Reviewer, Not the Review](https://blakecrosley.com/blog/agents-supersede-the-reviewer): A 2026 paper argues coding agents have ended human code review. I run the pipeline it prescribes: the reviewer role is dying, the review is relocating.
- [Computer-Use Agents Overshare by Default](https://blakecrosley.com/blog/computer-use-agents-contextual-integrity): A 2026 benchmark tested 15 frontier computer-use agents for data leakage across contexts. Eleven leaked on over half the scenarios. No attacker needed.
- [Context Compaction Is a Decision, Not a Threshold](https://blakecrosley.com/blog/agent-context-compaction): Coding agents compact context when a counter trips, not at a safe stopping point. A 2026 paper shows model-decided compaction cuts cost 30-70%.
- [SwiftData Performance Is a Storage Problem](https://blakecrosley.com/blog/swiftdata-performance-storage-engine): What the WWDC 2026 SwiftData lab taught about performance: WAL concurrency, fetchCount and fetchIdentifiers, the Sendable boundary, and the aggregate gap.
- [Why Safari 27 Ships 525 Fixes: Notes From the WebKit Lab](https://blakecrosley.com/blog/webkit-lab-how-safari-ships): The WWDC 2026 Safari lab on how WebKit decides what to build: 525 fixes, a module-loader rewrite for top-level await, :has(), appearance: base, and more.
- [Apple's First-Party Answer to Prompt Injection](https://blakecrosley.com/blog/apple-prompt-injection-defense-wwdc26): WWDC 2026: Apple cites the lethal trifecta, ships deterministic guardrail APIs in Foundation Models and App Intents, and moves PCC onto Google Cloud.
- [Apple's Font Interpreter Is Now Swift, and 13% Faster](https://blakecrosley.com/blog/truetype-hinting-swift-migration): Apple's security team rewrote the TrueType hinting interpreter from C to memory-safe Swift, made it 13% faster, open-sourced it, and showed the techniques.
- [UIKit's Scene Mandate: What Fails to Launch on iOS 27](https://blakecrosley.com/blog/uikit-scene-lifecycle-mandate-ios-27): Apps built with the iOS 27 SDK must adopt the UIKit scene-based life cycle or they fail to launch. The timeline, the migration steps, and the agent skill.
- [Container Machines: A Persistent Linux Environment on Mac](https://blakecrosley.com/blog/container-machines-linux-mac): Apple's container tool hits 1.0 with container machine: a fast, persistent Linux environment on macOS with your user, home directory, and dotfiles mounted in.
- [ImageCreator Is Deprecated: What Breaks in iOS 27](https://blakecrosley.com/blog/imagecreator-deprecated-ios-27): Apple is discontinuing Image Playground's ImageCreator class in iOS 27, with TestFlight runtime errors in beta and compile failures at public release.
- [Xcode 27 Ships Agent Skills You Can Export Anywhere](https://blakecrosley.com/blog/xcode-27-agent-skills-export): Xcode 27 bundles two SwiftUI agent skills and a one-command exporter. xcrun agent skills export moves Apple's best practices into Claude Code or Codex.
- [What Apple's Performance Team Said in the WWDC26 Lab](https://blakecrosley.com/blog/apple-performance-team-lab-wwdc26): Apple's Power & Performance team answered live developer questions at WWDC26. Field guidance on MetricKit, Power Profiler, thermals, and AI contention.
- [What Apple's Swift Team Said in the WWDC26 Lab](https://blakecrosley.com/blog/swift-team-lab-wwdc26): Apple's Swift Group Lab at WWDC26 ran without captions. We transcribed it locally. Candid engineer answers on concurrency, ~Sendable, and the roadmap.
- [Apple Is Open-Sourcing the Foundation Models Framework](https://blakecrosley.com/blog/foundation-models-open-source): WWDC 2026: the Foundation Models framework goes open source this summer, so the same Swift API runs server-side, plus a new Skills package live on GitHub.
- [USDKit: Swift-Native OpenUSD on Apple Platforms](https://blakecrosley.com/blog/usdkit-openusd-2026): USDKit brings first-class OpenUSD to Swift: open a stage, reference assets via composition, author accessibility, and export with mesh compression in 2026.
- [Loop Engineering: Loops Win Where Verification Is Cheap](https://blakecrosley.com/blog/loops-win-where-verification-is-cheap): Loop engineering, checked against Boris Cherny's full transcripts: every loop he names has cheap verification. That constraint decides what to automate.
- [CSS Grid Lanes: Native Masonry in Safari](https://blakecrosley.com/blog/css-grid-lanes-2026): CSS Grid Lanes brings native masonry layout to Safari 26.4 in three lines of CSS, with a flow-tolerance dial that fixes masonry's old tab-order problem.
- [MetricKit Rebuilt: State-Aware Telemetry in iOS 27](https://blakecrosley.com/blog/metrickit-ios-27-state-reporting): MetricKit is rebuilt in iOS 27: async metric and diagnostic streams, Codable reports, and a StateReporting framework that splits metrics by app state.
- [Foundation Models from Python: the fm CLI](https://blakecrosley.com/blog/foundation-models-python-fm-cli): macOS 27 ships the fm command line tool plus a Foundation Models SDK for Python, so you can script Apple's on-device model and build evaluation pipelines.
- [Meet Music Understanding: On-Device Audio Analysis](https://blakecrosley.com/blog/music-understanding-framework-ios-27): Music Understanding is Apple's on-device framework for analyzing a song's key, rhythm, structure, pace, instrument activity, and loudness in Swift code.
- [Foundation Models Image Input in iOS 27](https://blakecrosley.com/blog/foundation-models-image-input-ios-27): iOS 27 gives the on-device Foundation Models LLM Vision: drop a UIImage, CGImage, or pixel buffer into a prompt as an attachment, and reason over it.
- [What's New in Instruments 27 for App Responsiveness](https://blakecrosley.com/blog/instruments-27-app-responsiveness): Instruments 27 adds Top Functions, Run Comparisons, a Swift executors instrument, and a new Inspector panel to diagnose CPU, actor, and syscall hangs.
- [The HTML <model> Element Comes to Every Apple OS](https://blakecrosley.com/blog/html-model-element-apple-platforms): The HTML model element now renders drop-in 3D in Safari on iOS, iPadOS, and macOS with stagemode, entityTransform, baked animation, and AR Quick Look.
- [Running Agentic AI on the Mac with MLX](https://blakecrosley.com/blog/agentic-ai-mac-mlx): WWDC 2026: run the full agentic AI loop locally on the Mac with MLX, scale it across multiple Macs, then secure and profile it with Apple's frameworks.
- [App Schemas: Make Your App Available to Siri](https://blakecrosley.com/blog/app-schemas-siri-ios-27): App Schemas describe an app's content and actions in terms Siri already understands, so Siri reasons over your data and acts on it, no training phrases.
- [Game Porting Toolkit 4: Agentic Game Ports on Mac](https://blakecrosley.com/blog/game-porting-toolkit-4-agentic): Game Porting Toolkit 4 ships agentic porting skills as a Claude Code plugin plus gpucapture and gpudebug CLI tools. Cyberpunk's manual port set the bar.
- [Customizable Select: Style the Real <select> at Last](https://blakecrosley.com/blog/customizable-select-safari-27): Safari 27 and Chrome 135 let you style the real select element: appearance: base-select, ::picker(select), rich HTML in options, and a swappable button.
- [Accessibility in iOS 27: Reading Apps & Custom Controls](https://blakecrosley.com/blog/accessibility-ios-27): iOS 27 accessibility for reading apps and custom controls: text navigation linking, causesPageTurn, UITextInput, the adjustable trait, and direct touch.
- [Evaluations: XCTest for Model Quality (iOS 27)](https://blakecrosley.com/blog/apple-evaluations-framework): Apple's Evaluations framework (iOS 27, all platforms) measures AI feature quality in Swift: Evaluator, ScoreDimension, Metric, ToolCallEvaluator, and a Swift Testing trait.
- [SwiftData in iOS 27: Observation and History](https://blakecrosley.com/blog/swiftdata-ios-27-observation-history): iOS 27 gives SwiftData first-class change observation with ResultsObserver, persistent-history observation with HistoryObserver, and codable attribute storage.
- [Xcode 27 Went Agentic](https://blakecrosley.com/blog/xcode-27-coding-agents): Xcode 27 builds coding agents into the IDE: plan-mode feature work, UI prototyping via previews, agent-driven localization, and Xcode Cloud automation.
- [What's New in visionOS 27 for Spatial Devs](https://blakecrosley.com/blog/whats-new-visionos-27): visionOS 27 adds Spatial Preview from the Mac, Foveated Streaming from a PC, immersive Safari environments, metric-space object tracking, and RealityKit.
- [Foundation Models on Private Cloud Compute](https://blakecrosley.com/blog/foundation-models-private-cloud-compute): iOS 27 adds a server-scale Foundation Model on Private Cloud Compute with on-device privacy, plus a protocol to plug in your own LLM provider.
- [RealityKit And Reality Composer Pro 3 In 2026](https://blakecrosley.com/blog/realitykit-reality-composer-pro-3): WWDC26 matured Apple's spatial pipeline: RealityKit lighting and cloth, plus a standalone Reality Composer Pro 3 with live preview and Xcode plug-ins.
- [Foundation Models in iOS 27: Tool-Calling Control](https://blakecrosley.com/blog/foundation-models-tool-calling-ios-27): iOS 27 adds GenerationOptions.ToolCallingMode to steer how the on-device model uses tools, plus built-in Vision tools: OCRTool and BarcodeReaderTool.
- [App Intents in iOS 27: Background, Sync, Spotlight](https://blakecrosley.com/blog/app-intents-ios-27-background-execution): iOS 27 gives App Intents background execution past 30 seconds via LongRunningIntent, cross-device identity with SyncableEntity, and Spotlight reindexing.
- [On-Device AI Across iOS 27: Spotlight and Media](https://blakecrosley.com/blog/on-device-ai-spotlight-media-ios-27): iOS 27 threads the on-device model through the system: SpotlightSearchTool makes Core Spotlight LLM-grounded, and AVFoundation generates subtitles on device.
- [Metal for Machine Learning in 2026](https://blakecrosley.com/blog/metal-machine-learning-2026): WWDC26 made Metal a first-class ML compute surface: Metal tensors for custom kernels, the M5 neural accelerator, real-time neural rendering, and MLX Swift.
- [Core AI: Running Models on Apple Silicon](https://blakecrosley.com/blog/core-ai-run-models-apple-silicon): Core AI is iOS 27's low-level model-execution framework: asset vs model, NDArray tensors, compute-unit targeting, and inference functions on Apple silicon.
- [What's New in SwiftUI for iOS 27](https://blakecrosley.com/blog/whats-new-swiftui-ios-27): iOS 27 reworks SwiftUI lists, documents, toolbars, and errors: drag-to-reorder, a readable/writable document model, toolbar overflow, item-based alerts.
- [SwiftUI Performance and Interop in iOS 27](https://blakecrosley.com/blog/swiftui-performance-interop-ios-27): How iOS 27 SwiftUI handles lazy-stack scrolling, GPU shader effects, and AppKit/UIKit interop, drawn from three official WWDC26 UI Frameworks sessions.
- [Building a Responsive Camera App in iOS 27](https://blakecrosley.com/blog/responsive-camera-app-ios-27): iOS 27 cuts camera launch in half with Deferred Start, adds Pro Video Storage for ProRes writes, and brings the Center Stage square front camera to your app.
- [HealthKit in iOS 27: Workout Zones, New Types](https://blakecrosley.com/blog/healthkit-ios-27-workout-zones): iOS 27 makes workout heart-rate zones first-class HealthKit data via HKWorkoutZoneConfiguration and HKWorkoutZoneGroup, plus new menopausalState types.
- [What's New in Swift (2026): The WWDC26 Update](https://blakecrosley.com/blog/whats-new-swift-2026): Swift 6.3 and 6.4 from WWDC26: anyAppleOS availability, module selectors, borrow/mutate accessors, the Iterable protocol, Swift Testing interop, and MLX.
- [Your Agent Has Two Untrusted Inputs](https://blakecrosley.com/blog/agent-two-untrusted-inputs): AI agents have two untrusted inputs: code the model writes and tool output it reads. One now has a real WASM sandbox; the other, MCP tool poisoning, does not.
- [Engineering Philosophy: Mark Shuttleworth](https://blakecrosley.com/blog/engineering-philosophy-mark-shuttleworth): Mark Shuttleworth built Ubuntu on one idea -- Linux for human beings, free software for everyone -- grounded in ubuntu: humanity to others, shipped on a clock.
- [Engineering Philosophy: Sophie Wilson](https://blakecrosley.com/blog/engineering-philosophy-sophie-wilson): Sophie Wilson designed the ARM instruction set -- now in nearly every phone on Earth -- with a tiny team and a ruthless RISC efficiency that made low power almost an accident.
- [Engineering Philosophy: Margaret Hamilton](https://blakecrosley.com/blog/engineering-philosophy-margaret-hamilton): Margaret Hamilton coined 'software engineering' and wrote the Apollo flight code that survived the 1202 alarm. Defensive design, error recovery, and no second chance.
- [Engineering Philosophy: Roberto Ierusalimschy](https://blakecrosley.com/blog/engineering-philosophy-roberto-ierusalimschy): Roberto Ierusalimschy designed Lua around one principle -- mechanisms, not policy -- a small, fast, embeddable language that hands you the levers instead of the rules.
- [Apple's Translation Framework: Free, On-Device, and Sharper Than It Looks](https://blakecrosley.com/blog/apple-translation-framework-on-device): Apple's Translation framework: free on-device translation via translationPresentation and TranslationSession, plus the offline-download edges demos skip.
- [Engineering Philosophy: Satoru Iwata](https://blakecrosley.com/blog/engineering-philosophy-satoru-iwata): Satoru Iwata was a programmer who became Nintendo's president without ever stopping being a gamer -- technical mastery in service of the player's joy.
- [The iOS 26 Widget Surface: One App Intent, Many Places](https://blakecrosley.com/blog/ios-26-widget-and-control-surface): iOS 26 widgets, Control Center controls, and Live Activities are all App Intents surfaces. One intent powers buttons, controls, and Live Activity actions.
- [Engineering Philosophy: Raj Reddy, Technology for the Bottom Billion](https://blakecrosley.com/blog/engineering-philosophy-raj-reddy): Raj Reddy pioneered machines you can talk to -- speech recognition, the blackboard model -- then aimed the most advanced AI at the world's poorest, not its richest.
- [Engineering Philosophy: Geoffrey Hinton, Conviction Over Fashion](https://blakecrosley.com/blog/engineering-philosophy-geoffrey-hinton): Geoffrey Hinton bet on brain-like neural networks through two AI winters when the field mocked them -- conviction over fashion, intuition over formalism.
- [Engineering Philosophy: Yann LeCun, Learning the World, Openly](https://blakecrosley.com/blog/engineering-philosophy-yann-lecun): Yann LeCun built deep vision on convolution, then bet that real intelligence comes from learning the world unsupervised and publishing it openly -- not bigger LLMs.
- [MLX on Apple Silicon: When You Need Your Own Model, Not Apple's](https://blakecrosley.com/blog/mlx-on-device-ml-apple-silicon): Foundation Models gives you Apple's sealed on-device LLM. MLX runs your own: quantized open-weight models and LoRA fine-tunes on Apple Silicon.
- [Engineering Philosophy: Fei-Fei Li, Data Is the Foundation](https://blakecrosley.com/blog/engineering-philosophy-fei-fei-li): Fei-Fei Li gave AI its eyes by building ImageNet -- betting that data at scale, not a cleverer model, was the missing ingredient, and that AI must stay human-centered.
- [Engineering Philosophy: Adi Shamir](https://blakecrosley.com/blog/engineering-philosophy-adi-shamir): Adi Shamir is the S in RSA and a master cryptanalyst -- he builds secure systems by also learning to break them. Attack to defend, turning clean number theory into mechanism.
- [Engineering Philosophy: Salvatore Sanfilippo (antirez)](https://blakecrosley.com/blog/engineering-philosophy-antirez): Salvatore Sanfilippo built Redis around one principle -- do less. A small, single-threaded, in-memory store you can hold in your head, written in C for humans to read.
- [Engineering Philosophy: Kyunghyun Cho](https://blakecrosley.com/blog/engineering-philosophy-kyunghyun-cho): Kyunghyun Cho let models learn their own control structure -- gated memory in the GRU, soft alignment in attention -- and paired it with honest, reproducible science.
- [Engineering Philosophy: Demis Hassabis, Solve Intelligence to Solve Everything](https://blakecrosley.com/blog/engineering-philosophy-demis-hassabis): Demis Hassabis built general intelligence from first principles -- games as the proving ground, neuroscience as inspiration -- then pointed it at protein folding and won a Nobel.
- [Engineering Philosophy: Werner Vogels](https://blakecrosley.com/blog/engineering-philosophy-werner-vogels): Werner Vogels, Amazon's CTO, built the cloud on one assumption: everything fails all the time. Design for failure, minimize blast radius, and stay available through it.
- [Apple Foundation Models: The On-Device LLM Framework, Explained](https://blakecrosley.com/blog/apple-foundation-models-framework): Apple's Foundation Models framework: LanguageModelSession, @Generable guided generation, tool calling, availability, and when to leave the on-device model.
- [Engineering Philosophy: Jim Keller, Transistors Are Free](https://blakecrosley.com/blog/engineering-philosophy-jim-keller): Jim Keller architected the chips behind AMD's comeback, the iPhone, Tesla's Autopilot and more -- by spending silicon to remove bottlenecks and rethinking from first principles.
- [Swift 6.2 Concurrency in Practice: Default to MainActor, Escape on Purpose](https://blakecrosley.com/blog/swift-6-2-concurrency-in-practice): Swift 6.2 inverts concurrency: default your module to MainActor (SE-0466), run nonisolated async on the caller (SE-0461), escape with @concurrent.
- [Engineering Philosophy: Joanna Rutkowska](https://blakecrosley.com/blog/engineering-philosophy-joanna-rutkowska): Joanna Rutkowska built Qubes OS on reasonable paranoia: you cannot make software bug-free, so assume compromise, distrust the infrastructure, and isolate the blast radius.
- [Engineering Philosophy: Radia Perlman](https://blakecrosley.com/blog/engineering-philosophy-radia-perlman): Radia Perlman invented the Spanning Tree Protocol and built networks that heal themselves -- loop-free, self-stabilizing, and correct even when nodes lie. Robustness as a first principle.
- [Engineering Philosophy: Bjarne Stroustrup, Abstraction Without Overhead](https://blakecrosley.com/blog/engineering-philosophy-bjarne-stroustrup): Bjarne Stroustrup built C++ on the zero-overhead principle: never choose between expressive code and bare-metal speed. A good abstraction costs nothing.
- [Engineering Philosophy: Barbara Liskov, The Contract Is the Type](https://blakecrosley.com/blog/engineering-philosophy-barbara-liskov): Barbara Liskov made data abstraction a programming primitive: a type is the contract it keeps, and a subtype must honor every promise its supertype makes.
- [Engineering Philosophy: Tim Berners-Lee, This Is for Everyone](https://blakecrosley.com/blog/engineering-philosophy-tim-berners-lee): Tim Berners-Lee invented the web and gave it away: universality and permissionless decentralization -- anyone, anywhere can publish and link without asking.
- [Engineering Philosophy: Rich Hickey, Simple Is Not Easy](https://blakecrosley.com/blog/engineering-philosophy-rich-hickey): Rich Hickey built Clojure and Datomic on one distinction: simple is not easy. Simple means un-braided, one concern per thing; easy just means familiar.
- [Engineering Philosophy: Grace Hopper, Make the Computer Speak Human](https://blakecrosley.com/blog/engineering-philosophy-grace-hopper): Grace Hopper built the first compiler so programs could be written in human language, made latency physical with a nanosecond wire, and fought stale dogma.
- [Engineering Philosophy: Guido van Rossum, Readability Counts](https://blakecrosley.com/blog/engineering-philosophy-guido-van-rossum): Guido van Rossum built Python on one bet: code is read far more often than it is written, so the language itself should optimize for the human reading it.
- [Engineering Philosophy: Donald Knuth, Programming Is an Art](https://blakecrosley.com/blog/engineering-philosophy-donald-knuth): Donald Knuth treats programming as an art written to be read by humans. Measure before you cut, optimize only the critical 3%, and prove correctness with craft.
- [Engineering Philosophy: Edsger Dijkstra, Elegance Is Not Optional](https://blakecrosley.com/blog/engineering-philosophy-edsger-dijkstra): Edsger Dijkstra treated simplicity as the precondition for correctness and proof as superior to testing -- elegance was not optional but the whole discipline.
- [Engineering Philosophy: Alan Kay, The Big Idea Is Messaging](https://blakecrosley.com/blog/engineering-philosophy-alan-kay): Alan Kay invented the future by changing the point of view: computing as a medium for thought, with systems built from objects communicating by messages.
- [Engineering Philosophy: Leslie Lamport, Think Before You Code](https://blakecrosley.com/blog/engineering-philosophy-leslie-lamport): Leslie Lamport made distributed systems a science: time is not global, causality is what is real, and you specify the design before you write the code.
- [Engineering Philosophy: Thompson & Ritchie, Do One Thing Well](https://blakecrosley.com/blog/engineering-philosophy-thompson-ritchie): Thompson and Ritchie built Unix and C from small sharp tools composed through one universal interface: text streams and pipes. Simplicity over features.
- [Engineering Philosophy: Andrej Karpathy, The Stack You Don't Write](https://blakecrosley.com/blog/engineering-philosophy-andrej-karpathy): Andrej Karpathy reframed neural networks as Software 2.0 -- a stack compiled from data, not written by hand -- and taught a generation to build it from scratch.
- [Engineering Philosophy: John Carmack, Performance as Moral Craft](https://blakecrosley.com/blog/engineering-philosophy-john-carmack): John Carmack treats performance as a moral question. Strip to the fast, simple core, understand the problem to its foundation, ship it, and show your work.
- [Engineering Philosophy: Yukihiro Matsumoto, Designed for Humans](https://blakecrosley.com/blog/engineering-philosophy-yukihiro-matsumoto): Matz built Ruby to make programmers happy: language as human-centered design, the principle of least surprise, and a community that became a design output.
- [Engineering Philosophy: Linus Torvalds, The Special Case That Disappears](https://blakecrosley.com/blog/engineering-philosophy-linus-torvalds): Linus Torvalds defines good taste as code where the special case disappears -- the engineering conviction behind the Linux kernel, git, and \"show me the code.\"
- [When the Maintainer Is the Attacker: jqwik 1.10.0](https://blakecrosley.com/blog/when-the-maintainer-is-the-attacker): jqwik 1.10.0 emits a destructive prompt-injection string in Maven output. ANSI escapes hide it from humans. The maintainer added it on purpose.
- [Loopback Is Not a Trust Boundary: CVE-2026-2611](https://blakecrosley.com/blog/loopback-is-not-a-trust-boundary): MLflow 3.9.0's Assistant exposed a local AI agent on /ajax-api with no CORS check. Any webpage could take over Claude Code. The bug is older than MLflow.
- [Deep Research Agents Need Evidence Graphs](https://blakecrosley.com/blog/deep-research-agents-evidence-graphs): Deep research agents need evidence graphs to track missing pieces, reduce duplicate searches, and produce source-traced answers reviewers can inspect.
- [Agents.txt Is Not Access Control](https://blakecrosley.com/blog/agents-txt-not-access-control): Agents.txt is not access control. Use robots.txt, llms.txt, bot verification, logs, and server-side policy to manage AI crawlers without false confidence.
- [AI Agents Should Call Models](https://blakecrosley.com/blog/ai-agents-should-call-models): AI agents should call trained machine-learning models as tools instead of asking an LLM to guess prices, risk scores, forecasts, or classifications.
- [AI Agent Ownership Is the Trust Primitive](https://blakecrosley.com/blog/ai-agent-ownership-trust-primitive): AI agent ownership links every autonomous action to the account, session, scope, and operator who can stop it, review it, and accept responsibility.
- [Research Papers Need Agent-Readable Claim Files](https://blakecrosley.com/blog/research-papers-agent-readable-claim-files): Agent-readable claim files let papers expose claims, scope limits, definitions, and figure commands so research agents cite, test, and reuse them safely.
- [AI Agent Config Security Is Supply Chain Security](https://blakecrosley.com/blog/ai-agent-config-supply-chain): AI agent config security belongs in supply-chain review: hooks, editor tasks, install scripts, MCP files, and plugins can execute code before you notice.
- [MCP Tools Need Action-Level Authorization](https://blakecrosley.com/blog/mcp-tools-need-action-level-authorization): MCP tools need action-level authorization: bearer-token validation must lead to per-tool, per-role, and per-action capability checks before agents act.
- [AI Agent Monitoring Needs Runtime Intervention](https://blakecrosley.com/blog/ai-agent-monitoring-runtime-intervention): AI agent monitoring should catch decisive errors during a run, not after failure. Runtime intervention turns traces, policies, and alerts into safe pauses.
- [Agent Keys Need Risk Budgets](https://blakecrosley.com/blog/agent-keys-need-risk-budgets): Shuriken's Agent Kit shows why AI agent tools that can act need scoped keys, server-side limits, activity logs, revocation, and conservative defaults.
- [AI Agent Skills Need Behavioral Audits, Not Pass Rates](https://blakecrosley.com/blog/ai-agent-skills-behavioral-audits): AI agent skills can change behavior while pass rates stay flat. Behavioral audits compare traces, declared capabilities, and side effects before trust.
- [Long-Running AI Agents Need Durable Channels](https://blakecrosley.com/blog/long-running-ai-agents-durable-channels): Long-running AI agents need durable channels: workflow IDs, event logs, resumable streams, typed signals, safe cancellation, and user-visible checkpoints.
- [AI Agent Safety Starts With Small Software](https://blakecrosley.com/blog/ai-agent-safety-small-software): AI agent safety starts with small software: smaller tools, plain files, narrow permissions, and faster tests give coding agents fewer places to hide bugs.
- [AI Agents Need Exploration Checkpoints](https://blakecrosley.com/blog/ai-agents-need-exploration-checkpoints): Exploration checkpoints let AI agents prove what they discovered before acting, reducing premature exploitation, brittle plans, and generic world models.
- [AI Coding Agents Need Smaller Review Surfaces](https://blakecrosley.com/blog/ai-coding-agents-smaller-review-surfaces): AI coding agents overwhelm reviewers with giant diffs. Smaller review surfaces keep engineers engaged, verification-focused, and accountable before merge.
- [AI Malware Analysis Needs Evidence Packets](https://blakecrosley.com/blog/ai-malware-analysis-evidence-packets): AI malware analysis needs evidence packets: hashes, commands, indicators, and claim-to-evidence trails matter more than confident agent summaries.
- [AI Code Review Needs Dissent, Not Consensus](https://blakecrosley.com/blog/ai-code-review-needs-dissent): AI code review needs independent agents that preserve dissent, validate findings, route uncertainty to humans, and re-review fixes before teams merge PRs.
- [AI Agent Approval Prompts Are Not Authorization](https://blakecrosley.com/blog/ai-agent-approval-prompts-not-authorization): AI agent approval prompts need scoped authority, risk lanes, audit logs, expiry, and revocation so humans approve concrete actions, not fluent requests.
- [Agent Skills Need Package Managers](https://blakecrosley.com/blog/agent-skills-need-package-managers): Agent skills, MCP servers, prompts, hooks, and commands now behave like dependencies. Teams need manifests, lockfiles, policy gates, review, and rollback.
- [Rust's Draft LLM Policy Draws the Right Line](https://blakecrosley.com/blog/rust-draft-llm-policy): Rust's draft LLM usage policy allows AI for learning, review, and experiments while banning generated comments, docs, and human-review shortcuts in Rust.
- [Codex Hooks Make the Harness Real](https://blakecrosley.com/blog/codex-hooks-make-the-harness-real): Codex hooks, Remote SSH, and mobile control make agent work operational. Evidence, approvals, git custody, release gates, and taste now decide quality.
- [Open Source Is Not a Security Boundary](https://blakecrosley.com/blog/open-source-is-not-a-security-boundary): GDS guidance on AI vulnerability discovery gets open-source security right: hide less by default, fix faster, and make exceptions explicit with evidence.
- [Agent Code Search Has a Token Budget](https://blakecrosley.com/blog/agent-code-search-token-budget): Semble turns code search into a context-budget problem: hybrid retrieval, ranked snippets, and token savings beat grep-and-read loops for coding agents.
- [AI Agent Review Packets Are the New Final Answer](https://blakecrosley.com/blog/review-packets-are-the-new-final-answer): AI agent review packets bundle claims, traces, approvals, tests, deployment proof, human review state, and unresolved gaps so agent work earns real trust.
- [Agent Search Is a Runtime Problem](https://blakecrosley.com/blog/agent-search-is-a-runtime-problem): A new arXiv study compares grep and vector retrieval across Chronos, Claude Code, Codex, and Gemini CLI. Agent search quality lives in the runtime layer.
- [The Agent Interface Is the Harness](https://blakecrosley.com/blog/agent-interface-is-the-harness): Agent interface design is the operating layer: permissions, memory, traces, evidence, recovery, and taste decide whether autonomous AI agents earn trust.
- [HTML Is the Format AI Agents Want](https://blakecrosley.com/blog/html-is-the-format-agents-want): Thariq Shihipar's HTML examples show why agent output format matters: spatial structure, interaction, and visual evidence beat flattened Markdown.
- [Agents Need Supervision Surfaces](https://blakecrosley.com/blog/agents-need-supervision-surfaces): Agent supervision surfaces turn autonomous AI work into inspectable operations: approvals, traces, evidence, recovery, and review queues beat better chat.
- [Agentic Design Is Control Surface Design](https://blakecrosley.com/blog/agentic-design-control-surface): Agentic design is not a prettier chat box. It is the control surface that makes autonomous software visible, interruptible, auditable, and worthy.
- [Agent Execution Traces Are the Runtime Contract](https://blakecrosley.com/blog/agent-execution-traces-runtime-contract): Shepherd, AI Workflow Store, and WildClawBench point to the same agent reliability layer: typed traces, reusable workflows, and native-runtime evaluation.
- [Managed Agents vs Local Agent Harnesses: What to Keep](https://blakecrosley.com/blog/managed-agents-vs-local-ai-agent-harnesses): Managed agents now handle sessions, sandboxes, tracing, and events. Keep local harness rules for taste, evidence, privacy, and publishing safely today.
- [Code with Claude SF 2026: What Anthropic Actually Shipped](https://blakecrosley.com/blog/code-with-claude-sf-2026-recap): Recap of Code with Claude SF 2026: doubled Claude Code rate limits, the SpaceX Colossus 1 deal, 10 finance agent templates, and Vercept's acquisition.
- [Apple Silicon TBDR: What App Developers Actually Get](https://blakecrosley.com/blog/apple-silicon-tbdr): Apple silicon GPUs use tile-based deferred rendering. Imageblocks, tile shaders, raster order groups, and A11+ enhancements that change Metal app design.
- [App Intents 2.0 in iOS 26: Visual Intelligence and Snippets](https://blakecrosley.com/blog/app-intents-2-ios-26-additions): iOS 26 expanded App Intents with IntentValueQuery for Visual Intelligence, @DeferredProperty for async values, interactive snippets, entity view annotations.
- [Foundation Models Custom Adapters: When To Train One](https://blakecrosley.com/blog/foundation-models-custom-adapters): iOS 26 Foundation Models custom adapters train LoRA weights, export .fmadapter packages, ship via Background Assets, and require Apple's entitlement.
- [Genmoji and NSAdaptiveImageGlyph: Inline Emoji on iOS 18+](https://blakecrosley.com/blog/genmoji-nsadaptiveimageglyph): Genmoji ships as NSAdaptiveImageGlyph in attributed text. Apps using UITextView with TextKit 2 enable supportsAdaptiveImageGlyph and handle serialization.
- [Metal 4 Essentials: What The New Core API Actually Changes](https://blakecrosley.com/blog/metal-4-essentials): Metal 4 ships parallel MTL4-prefixed types alongside Metal in iOS 26. Multi-threaded command encoding, unified compute, and ML as a first-class GPU pass.
- [Foundation Models Use Cases: General vs Content Tagging](https://blakecrosley.com/blog/foundation-models-use-cases): iOS 26 Foundation Models has .general and .contentTagging use cases. Use Apple's rules to decide when prompting beats specialization.
- [Image Playground API: SwiftUI Sheet, Programmatic Image Creator, And Style Control](https://blakecrosley.com/blog/image-playground-api-integration): Image Playground gives apps two paths: the SwiftUI imagePlaygroundSheet modifier and the programmatic ImageCreator API for generating images from concepts.
- [AVFoundation HDR And Apple Log: Pro Video Workflows On iPhone](https://blakecrosley.com/blog/avfoundation-hdr-apple-log): iPhone 15 Pro+ records Apple Log alongside HEVC and ProRes. AVFoundation exposes HDR (HLG, HDR10, Dolby Vision) and Apple Log through AVCaptureDevice.
- [SwiftUI Layout Protocol: Building Custom Layouts From sizeThatFits To placeSubviews](https://blakecrosley.com/blog/swiftui-layout-protocol-deep-dive): iOS 16's Layout protocol lets apps build custom layouts with two methods. sizeThatFits, placeSubviews, the proposal contract, layout values, and caching.
- [@Observable Internals: The Macro, The Registrar, And What ObservableObject Got Wrong](https://blakecrosley.com/blog/observable-internals-swiftui): @Observable replaces ObservableObject's broadcast model with per-property access tracking. The macro expansion, the registrar, and the migration trap.
- [Custom SF Symbols: The Variable Template And The Three Required Sources](https://blakecrosley.com/blog/custom-sf-symbols-creation): SF Symbols creates 27 variations from three source designs. The variable template, compatible-data path requirements, rendering modes, and the Xcode handoff.
- [HealthKit Workout Lifecycle: HKWorkoutSession States And The iOS 26 Cross-Platform Surface](https://blakecrosley.com/blog/watchos-workout-lifecycle): watchOS workout sessions move through a six-state lifecycle. iOS 26 brought HKWorkoutSession to iPhone. The state machine, the live builder, and the delegate.
- [Claude Code to Codex Migration Guide 2026](https://blakecrosley.com/blog/claude-code-to-codex-migration): Claude Code to Codex migration guide: move AGENTS.md, skills, hooks, profiles, MCP, public-writing gates, and verified CLI notes from real local data.
- [tvOS Focus Engine: SwiftUI Patterns for the Siri Remote](https://blakecrosley.com/blog/tvos-focus-engine-swiftui): Apple TV navigates by focus, not touch. SwiftUI's .focusable, @FocusState, focusSection, and prefersDefaultFocus are the vocabulary. The patterns that ship.
- [Apple's New Speech Framework: SpeechAnalyzer vs SFSpeechRecognizer](https://blakecrosley.com/blog/speech-framework-vs-sfspeechrecognizer): iOS 26 introduces SpeechAnalyzer with SpeechTranscriber + SpeechDetector modules, an on-device replacement for SFSpeechRecognizer. When to migrate.
- [Writing Tools API: How Apps Plug Into Apple Intelligence's Writing Layer](https://blakecrosley.com/blog/writing-tools-api-adoption): iOS 18 introduced Writing Tools. iOS 26 makes adoption a single property for standard text views, and a designed coordinator API for custom text engines.
- [Symbol Effects: SwiftUI's Built-In Animation Vocabulary For Every Icon](https://blakecrosley.com/blog/symbol-effects-vocabulary): SF Symbols ships an animation vocabulary every iOS app can speak. Bounce, pulse, scale, replace, variable color, breathe: already designed, accessible, free.
- [Apple Vision Framework: On-Device CV Most Devs Skip](https://blakecrosley.com/blog/vision-framework-built-in): Apple Vision ships more than two dozen on-device CV operations. Most devs default to OpenAI Vision for tasks Vision performs in milliseconds, free, on-device.
- [The Privacy Manifest Deep Dive: What Counts As Data Collection](https://blakecrosley.com/blog/privacy-manifest-deep-dive): Apple's privacy manifest is a structured contract, not a checkbox: four sections, five required-reason API categories, SDK rules, common gotchas.
- [SF Pro: Variable Axes, Optical Sizing, And The Dynamic Type Contract](https://blakecrosley.com/blog/sf-pro-typography-system): Apple's system font ships with three variable axes and continuous optical sizing. The vocabulary that makes typography work across the Apple platforms.
- [visionOS Spatial Patterns Beyond the Window](https://blakecrosley.com/blog/visionos-spatial-patterns): Apps that float an iPad UI on Vision Pro miss the platform. Windows, Volumes, Immersive Spaces, ornaments, attachments: the visionOS-native vocabulary.
- [SwiftData Migrations: Lightweight vs Custom, And When You Don't Need a V2](https://blakecrosley.com/blog/swiftdata-migrations-guide): SwiftData's migration model uses VersionedSchema, MigrationStage, and SchemaMigrationPlan. Most schema changes don't need a V2 schema; the cases that do, do.
- [Core ML On-Device Inference: The Patterns That Actually Ship](https://blakecrosley.com/blog/core-ml-on-device-inference): Core ML runs models on Neural Engine, GPU, or CPU. The patterns that ship: model conversion, dispatch hinting, latency budgets, and quantization.
- [The Apple Platform Matrix: Which Targets Deserve Which App](https://blakecrosley.com/blog/apple-platform-matrix): iOS, iPad, Mac, Watch, Vision, TV. Six platforms, six obligations. Picking Apple targets is a product decision before it is an engineering one.
- [Swift Testing: The Framework Replacing XCTest, and What Stays In XCTest](https://blakecrosley.com/blog/swift-testing-vs-xctest): Swift Testing ships with Xcode 16+ and Swift 6. Macros, traits, parametrized tests, parallel by default. Migrate incrementally; UI tests stay in XCTest.
- [Accessibility As Platform: Personal Voice, Live Speech, Eye Tracking, Music Haptics](https://blakecrosley.com/blog/accessibility-platform-features): Personal Voice, Live Speech, Eye Tracking, Music Haptics, Vocal Shortcuts: accessibility as platform features, not app responsibilities.
- [Three Surfaces: Human, Apple Intelligence, Agent](https://blakecrosley.com/blog/three-surfaces-ios-app): Every iOS app capability faces three surfaces: human, Apple Intelligence, agent. Each has different obligations, rendering, latency, and trust posture.
- [Foundation Models Agentic Workflow: In-App Vs Tooling LLM](https://blakecrosley.com/blog/foundation-models-agentic-workflow): Two LLMs touch a Swift app. The on-device model that ships with the app and the agent that wrote the code. Different stacks, different obligations.
- [Hooks For Apple Development: Patterns That Save The Project](https://blakecrosley.com/blog/hooks-apple-development): An iOS agent has the developer's signing keys, builds, and project file reachable. Hooks bound the blast radius. Four shipping patterns.
- [Single Source Of Truth: SwiftData, MCP, iCloud](https://blakecrosley.com/blog/single-source-of-truth-pattern): Three callers can write to the same shopping list: a human, Apple Intelligence, and an external agent. Truth has to live somewhere. Pick the substrate.
- [What I Refuse To Write About](https://blakecrosley.com/blog/what-i-refuse-to-write-about): A blog cluster's voice comes from what it refuses to publish, not what it ships. Categorical, pattern, and interesting refusals each shape what the cluster is.
- [Foundation Models On-Device LLM: The Tool Protocol](https://blakecrosley.com/blog/foundation-models-on-device-llm): iOS 26's Foundation Models framework puts a 3B-parameter LLM on every Apple Intelligence device. The Tool protocol is the surface that makes the model useful.
- [SwiftData's Real Cost Is Schema Discipline](https://blakecrosley.com/blog/swiftdata-schema-discipline): SwiftData's API is two macros. The cost is what happens after you ship. Optional fields are the cheap migration; non-optional adds need a VersionedSchema.
- [Live Activities Are a State Machine, Not a Badge](https://blakecrosley.com/blog/live-activities-state-machine): Return's Live Activity looks like a Lock Screen countdown. It is a five-state lifecycle machine with three dismissal paths. The production code and bugs.
- [watchOS Runtime Is a Contract, Not a Background Task](https://blakecrosley.com/blog/watchos-runtime-contract): watchOS has no iOS-style background. WKExtendedRuntimeSession is the contract; without it, the app suspends on wrist drop. Pattern shipped in Return.
- [RealityKit And The Spatial Mental Model](https://blakecrosley.com/blog/realitykit-spatial-mental-model): RealityKit is an entity-component-system, not SwiftUI in 3D. Anchors place entities in real space. Five ways the model differs from a window.
- [App Intents vs MCP: The Routing Question](https://blakecrosley.com/blog/app-intents-vs-mcp-tools-frontier): Two protocols, one app. App Intents expose your app to Apple Intelligence. MCP exposes the same domain to Claude, ChatGPT, and the rest. The routing question.
- [What SwiftUI Is Made Of](https://blakecrosley.com/blog/what-swiftui-is-made-of): SwiftUI is a result-builder DSL on top of a value-typed View tree. Once the substrate is visible, AnyView, Group, and ViewBuilder stop being mysterious.
- [Five Apple Platforms, Three Shared Files: How Return Actually Ships Cross-Platform SwiftUI](https://blakecrosley.com/blog/shipping-swiftui-app-five-apple-platforms): Return runs on iPhone, iPad, Mac, Apple Watch, and Apple TV. Three Swift files are shared across all five targets out of 40 total. The rest is duplicated, and that is on purpose.
- [Liquid Glass in SwiftUI: Three Patterns From Shipping Return on iOS 26](https://blakecrosley.com/blog/liquid-glass-swiftui-patterns): Apple's Liquid Glass is a one-line SwiftUI API. Three patterns from Return go beyond .glassEffect(): glass on text via Core Text glyph paths, mirror reflection, and HUD overlays.
- [HealthKit + SwiftUI on iOS 26: Authorization, Sample Types, and Cross-Platform Patterns](https://blakecrosley.com/blog/healthkit-swiftui-patterns-ios-26): Real production patterns from Water (water tracking, HKQuantitySample) and Return (mindful sessions, HKCategorySample). Permission UX, async wrappers, watchOS variants, and the trap to avoid.
- [MCP Server Alongside an iOS App: Two Agent Ecosystems, One List](https://blakecrosley.com/blog/mcp-server-living-alongside-ios-app): Get Bananas runs on iOS, macOS, watchOS, and visionOS. It also lives inside Claude Desktop as an MCP server. Bridge: iCloud Drive plus a JSON file.
- [Claude Code Mac Desktop + Remote Control: A CLI User's Guide](https://blakecrosley.com/blog/claude-code-desktop-remote-control-guide): What changes when you move from `claude` in a terminal to the Mac desktop app, and how /remote-control lets you steer a local session from your phone without losing Xcode, MCP, or files.
- [App Intents Are Apple's New API to Your App](https://blakecrosley.com/blog/app-intents-are-apples-new-api-to-your-app): I shipped an App Intent in Water on Feb 8, 2026. Here's what Apple Intelligence wants from third-party apps in iOS 26, and why App Intents are the contract that matters.
- [The Cleanup Layer Is the Real AI Agent Market](https://blakecrosley.com/blog/cleanup-layer-is-the-real-ai-agent-market): Charlie Labs pivoted from building agents to cleaning up after them. The AI agent market is moving from generation to proof. Cleanup is the durable layer.
- [Reward the Tool Before the Answer](https://blakecrosley.com/blog/reward-the-tool-before-the-answer): AI agents fail when answers claim tool work that never happened. Four failure modes and the rule that catches them, with a tool-supervised RL parallel.
- [The Repo Shouldn't Get to Vote on Its Own Trust](https://blakecrosley.com/blog/repo-shouldnt-vote-on-its-own-trust): Two Claude Code trust dialog bypass CVEs in 37 days reveal a load-order failure. One invariant fixes it: interpret no workspace byte until the path is trusted.
- [The Steve Test: Does the Work Deserve to Exist?](https://blakecrosley.com/blog/the-steve-test): Steve Test vs Jiro Test: a product framework for deciding whether work deserves to exist, holds user trust, and belongs in the whole you are building.
- [John Ternus: The Builder CEO](https://blakecrosley.com/blog/john-ternus-builder-ceo): John Ternus becomes Apple CEO on September 1, 2026. Why Tim Cook's successor signals a builder-led era for Apple hardware, AI, and design.
- [Minimum Worthy Product](https://blakecrosley.com/blog/minimum-worthy-product): MVP became permission to ship weak work. Minimum Worthy Product is a different standard: ship the smallest product that earns belief.
- [The Workbench I Carry](https://blakecrosley.com/blog/workbench-i-carry): Steve Jobs's philosophy of invisible craft, operationalized: whole-widget integrity, refusal, and care inside an AI harness built on Claude Code.
- [The Agent Operator's Handbook: Supervising What You Can't See](https://blakecrosley.com/blog/agent-operators-handbook): Operating autonomous AI agents is a new discipline. Five responsibilities, a supervision stack, and an intervention framework define what operators do.
- [Taste Is a Technical System](https://blakecrosley.com/blog/taste-is-a-technical-system): Taste decomposes into constraints, evaluation criteria, pattern recognition, and coherence checks. Each component maps to engineering infrastructure.
- [Chat Is the Wrong Interface for AI Agents](https://blakecrosley.com/blog/chat-is-the-wrong-interface): Chat works for prompting but fails for agent operations. Six interface patterns replace the scrolling text window with real control surfaces.
- [The Design Engineer's Agent Stack](https://blakecrosley.com/blog/design-engineers-agent-stack): Design engineers need agent infrastructure that enforces visual consistency, typography discipline, color compliance, and taste. Here are the six components.
- [Cybersecurity Is Proof of Work: AI Attacks at $12,500 a Run](https://blakecrosley.com/blog/cybersecurity-is-proof-of-work): Claude Mythos completed a 32-step corporate network attack simulation in 3 of 10 tries. Each attempt cost $12,500 in tokens. Security is now a spending problem.
- [Runtime Defense for Tool-Augmented Agents](https://blakecrosley.com/blog/runtime-defense-tool-augmented-agents): ClawGuard demonstrates deterministic tool-call interception works. The Vercel telemetry incident shows why. Runtime defense is the enforceable layer.
- [Dark Factory Verification: When No Human Reads the Code](https://blakecrosley.com/blog/the-dark-factory-verification-layer): When humans stop reading code, what does the verification layer look like? Mapping the infrastructure required for fully autonomous AI coding.
- [Static Skills Are Dead Skills](https://blakecrosley.com/blog/static-skills-are-dead-skills): Agent skills decay the minute nobody watches the trajectories. A new paper on cross-user skill evolution frames the problem and the fix.
- [Your Agent Has Memory You Didn't Write](https://blakecrosley.com/blog/your-agent-has-memory-you-didnt-write): ACL 2026 paper measures LLM memory that existing evals miss: unconscious behavioral adaptation. Top models score under 66%. The asymmetry matters.
- [Your Agent Has a Middleman You Didn't Vet](https://blakecrosley.com/blog/your-agent-has-a-middleman): Researchers tested 28 LLM API routers. 17 touched AWS canary credentials. One drained ETH from a private key. The router layer is the new attack surface.
- [MCP Servers Are the New Attack Surface](https://blakecrosley.com/blog/mcp-servers-are-the-new-attack-surface): 50 MCP vulnerabilities, 30 CVEs in 60 days, 13 critical. Tool-use protocols are the attack surface nobody is auditing — here's the taxonomy and the fixes.
- [Project Glasswing: When a Model Finds Too Many Bugs](https://blakecrosley.com/blog/project-glasswing): Project Glasswing shows Anthropic restricting Claude Mythos after it found thousands of zero-days. What the rollout means for AI-assisted security.
- [When Your Agent Finds a Vulnerability](https://blakecrosley.com/blog/when-your-agent-finds-a-vulnerability): An Anthropic researcher found a 23-year-old Linux kernel vulnerability using Claude Code and a 10-line bash script. 22 Firefox CVEs followed.
- [What the Claude Code Source Leak Reveals](https://blakecrosley.com/blog/claude-code-source-leak): 11 findings from the Claude Code source leak: how auto mode, bash security, prompt caching, and multi-agent coordination actually work.
- [Design Philosophy: Pharrell Williams — Wealth Is of the Mind](https://blakecrosley.com/blog/design-philosophy-pharrell-williams): Pharrell Williams built Billionaire Boys Club, Humanrace, and a Louis Vuitton creative directorship by treating design as curation, not fabrication.
- [Fumihiko Maki's Design Philosophy: Creation Is Discovery](https://blakecrosley.com/blog/design-philosophy-fumihiko-maki): Fumihiko Maki built Hillside Terrace over 25 years, one phase at a time. His group form theory: buildings should participate in cities, not dominate.
- [Design Philosophy: Kashiwa Sato — A Strong Identity Is an Icon](https://blakecrosley.com/blog/design-philosophy-kashiwa-sato): Kashiwa Sato redesigned Uniqlo, 7-Eleven Japan, and 1,700 products by stripping brands to a single icon. His method: zero in on the essence, then compress.
- [Design Philosophy: Frank Lloyd Wright, Of the Hill, Not On It](https://blakecrosley.com/blog/design-philosophy-frank-lloyd-wright): Frank Lloyd Wright destroyed the box and built Fallingwater over a waterfall. His principle: a building should grow from its site like a plant.
- [Design Philosophy: Florence Knoll — I Am Not a Decorator](https://blakecrosley.com/blog/design-philosophy-florence-knoll): Florence Knoll invented the modern office by treating interiors as architecture, not decoration. Her Planning Unit changed how corporations think about space.
- [Design Philosophy: Paula Scher — Serious, Not Solemn](https://blakecrosley.com/blog/design-philosophy-paula-scher): Paula Scher sketched the Citibank logo in seconds on a napkin. It took her 34 years to learn how to draw it that fast. Speed is mastery, not carelessness.
- [Design Philosophy: Steve Jobs — The Back of the Fence](https://blakecrosley.com/blog/design-philosophy-steve-jobs): Steve Jobs wasn't a designer. He was the most demanding client a designer could have. His principle: use beautiful wood on the back of the cabinet.
- [Design Philosophy: Zaha Hadid, There Are 360 Degrees](https://blakecrosley.com/blog/design-philosophy-zaha-hadid): Zaha Hadid spent a decade as the 'paper architect' before her first building was built. She rejected the right angle and proved that fluidity is structural.
- [Design Philosophy: Futura — The Signature as Art](https://blakecrosley.com/blog/design-philosophy-futura): Futura started on NYC subway trains, broke from letterforms into pure abstraction, and proved that a graffiti tag is the original identity system.
- [Design Philosophy: Rejane Dal Bello — Citizen First](https://blakecrosley.com/blog/design-philosophy-rejane-dal-bello): Rejane Dal Bello designed an alphabet that degrades like Alzheimer's. Her method: distill complexity into a simple idea with human meaning.
- [Rick Rubin's Design Philosophy: Reduce Until Identity Breaks](https://blakecrosley.com/blog/design-philosophy-rick-rubin): Rick Rubin co-founded Def Jam, stripped songs to their essence, and wrote The Creative Act. His method: subtraction, attention, and taste as production.
- [Tobias Frere-Jones' Design Philosophy: Type Solves Problems](https://blakecrosley.com/blog/design-philosophy-tobias-frere-jones): Tobias Frere-Jones walked Manhattan block by block photographing signs, then built Gotham from what he found. His typefaces are civic infrastructure.
- [Design Philosophy: Matthew Carter, Type Hides Its Methods](https://blakecrosley.com/blog/design-philosophy-matthew-carter): Matthew Carter cut metal punches, then made Georgia and Verdana, the typefaces that taught screens to read. The constraint is the design.
- [Design Philosophy: Wang Shu — I Hate Perfect Things](https://blakecrosley.com/blog/design-philosophy-wang-shu): Wang Shu builds with bricks salvaged from demolished Chinese villages. His Amateur Architecture Studio is a protest against speed, waste, and forgetting.
- [Design Philosophy: Charles Harrison — The Quiet Giant](https://blakecrosley.com/blog/design-philosophy-charles-harrison): Charles Harrison designed the plastic trash can, the View-Master, and 750 products at Sears. His audience was the family on a quiet street.
- [Francis Kéré's Design Philosophy: Architecture as Objective](https://blakecrosley.com/blog/design-philosophy-diebedo-francis-kere): Kéré built his first school for his village while still a student. His buildings are climate systems, community projects, and architecture, all at once.
- [Neri Oxman's Design Philosophy: Editing Nature, Not Consuming It](https://blakecrosley.com/blog/design-philosophy-neri-oxman): Neri Oxman coined 'material ecology' and built structures grown by silkworms and 3D-printed in glass. Her method: design with biology, not against it.
- [Kunle Adeyemi: Makoko Floating School & Water Architecture](https://blakecrosley.com/blog/design-philosophy-kunle-adeyemi): Kunle Adeyemi built the Makoko Floating School on Lagos lagoon and iterated it across three continents. Climate-adaptive water cities.
- [Design Philosophy: Hiroshi Fujiwara — I Copy with Respect](https://blakecrosley.com/blog/design-philosophy-hiroshi-fujiwara): Hiroshi Fujiwara introduced hip-hop to Japan, co-created Harajuku streetwear, and built Fragment Design on one principle: the selection is the creation.
- [Design Philosophy: Daniel Arsham — Everything Becomes a Relic](https://blakecrosley.com/blog/design-philosophy-daniel-arsham): Daniel Arsham casts everyday objects in volcanic ash and crystal, then presents them as artifacts from the future. His method: future archaeology.
- [Design Philosophy: Don Norman — It's Not the User's Fault](https://blakecrosley.com/blog/design-philosophy-don-norman): Don Norman invented the term 'User Experience,' named the Norman Door, and proved that when a user fails, the design is broken -- not the person.
- [Design Philosophy: Tinker Hatfield — Show the Technology](https://blakecrosley.com/blog/design-philosophy-tinker-hatfield): Tinker Hatfield saw the Centre Pompidou and decided sneakers should show their guts too. His visible Air window changed footwear. His Jordan III saved Nike.
- [Design Philosophy: Kenya Hara, Emptiness, Not Simplicity](https://blakecrosley.com/blog/design-philosophy-kenya-hara): Kenya Hara designs for MUJI by removing everything that tells you what to think. His emptiness is not minimalism -- it is an invitation to participate.
- [Design Philosophy: Jony Ive, The Part You Never See](https://blakecrosley.com/blog/design-philosophy-jony-ive): Jony Ive didn't just design how Apple products looked -- he designed how they were made. The unibody process, the diamond-cut chamfer, the inside of the case.
- [Design Philosophy: Paul Rand — Don't Try to Be Original](https://blakecrosley.com/blog/design-philosophy-paul-rand): Paul Rand built American corporate identity with wit, play, and the conviction that one solution is enough. His logos for IBM, ABC, and NeXT still work.
- [Jan Tschichold's Design Philosophy: Repudiating His Own Manifesto](https://blakecrosley.com/blog/design-philosophy-jan-tschichold): Jan Tschichold wrote the manifesto for modernist typography, then spent his career arguing against it. Both positions were principled and correct.
- [Charles & Ray Eames' Design Philosophy: Details Are Design](https://blakecrosley.com/blog/design-philosophy-charles-ray-eames): Charles and Ray Eames turned a WWII leg splint into a furniture empire. Their method: constraints are gifts, details are the design, play is serious.
- [Design Philosophy: Tadao Ando, Concrete, Light, and the Void](https://blakecrosley.com/blog/design-philosophy-tadao-ando): Tadao Ando taught himself architecture from books, boxed professionally, then built the most spiritual spaces of the 20th century in concrete and light.
- [Design Philosophy: Susan Kare — Meaningful, Memorable, Clear](https://blakecrosley.com/blog/design-philosophy-susan-kare): Susan Kare designed the Macintosh icons with a $2.50 sketchbook and a 32x32 pixel grid. Her method -- meaningful, memorable, clear -- still works.
- [Design Philosophy: Virgil Abloh — Everything in Quotes](https://blakecrosley.com/blog/design-philosophy-virgil-abloh): Virgil Abloh turned a civil engineering degree and a 3% change into the most influential design career of the 2010s. Everything in quotes.
- [Design Philosophy: Dapper Dan — Knock-Ups, Not Knock-Offs](https://blakecrosley.com/blog/design-philosophy-dapper-dan): Dapper Dan built luxury fashion in Harlem with screen-printed logos and 27 Senegalese tailors. The brands that sued him eventually hired him back.
- [Design Philosophy: Dieter Rams — Less, But Better](https://blakecrosley.com/blog/design-philosophy-dieter-rams): Dieter Rams designed 500+ products at Braun by asking one question: what can I remove? His ten principles changed how we think about objects.
- [Every Hook Is a Scar: 84 Agent Failures Encoded in Code](https://blakecrosley.com/blog/every-hook-is-a-scar): 84 hooks intercept 15 of the 26 lifecycle event types Claude Code exposes. Each one traces back to a specific production failure: wiped caches, leaked credentials, phantom tests.
- [The Agent Didn't Get Smarter — The Project Did](https://blakecrosley.com/blog/the-agent-didnt-get-smarter): The model is the same between session 1 and session 500. The project changed. This reframes the entire AI productivity conversation.
- [Quality Is the Only Variable When AI Agents Build](https://blakecrosley.com/blog/quality-is-the-only-variable): Time, cost, resources, and effort are not constraints. The question is what's right, not what's efficient. A philosophy for building with AI agents.
- [What I Run Before I Sleep: 15,000 Pages Every Night](https://blakecrosley.com/blog/what-i-run-before-i-sleep): Every night: 15,000 pages checked, TTFB measured, cache verified, sitemaps crawled. The goodnight routine is where operational discipline lives.
- [The Handoff Document: Agent Memory Across Sessions](https://blakecrosley.com/blog/the-handoff-document): A diagnosis survived three corrections over four days and guided a fix that cut page load from 14s to 108ms. Handoffs carry context agents cannot.
- [Taste Is Infrastructure: Encoding Aesthetic Judgment for AI](https://blakecrosley.com/blog/taste-is-infrastructure): Agents have capability without opinion. The quality ceiling depends on how well you encode aesthetic judgment into hooks, gates, and constraints.
- [The Evidence Gate: Proof Over Plausibility in AI Output](https://blakecrosley.com/blog/the-evidence-gate): \"I believe\" and \"it should\" are not evidence. Every agent completion report needs a file path, test output, or specific code before marking work done.
- [Overnight: Why My Site Is Busier at 3am Than at 3pm](https://blakecrosley.com/blog/overnight): Googlebot crawls 21,000 pages overnight, Bingbot crawls 10,000, and my nightcheck grinds through 15,000. Bot traffic exceeds all human visitors combined.
- [Seventeen Thousand Signals](https://blakecrosley.com/blog/seventeen-thousand-signals): My vault has 17,900 signals from arXiv, Semantic Scholar, HN, NVD, and 9 other sources. Most are noise. The noise taught me what signal looks like.
- [The Fork Bomb Saved Us](https://blakecrosley.com/blog/the-fork-bomb-saved-us): The LiteLLM attacker made one implementation mistake. That mistake was the only reason 47,000 installs got caught in 46 minutes.
- [AI Agent Research: Claude Beat 33 Attack Methods](https://blakecrosley.com/blog/when-your-agent-becomes-the-researcher): Claude Code autonomously discovered adversarial attacks with 100% success rate against Meta's SecAlign-70B, beating all 33 published methods in 96 iterations.
- [Compound Context: Why AI Projects Improve Over Time](https://blakecrosley.com/blog/compound-context): Every problem you solve with an AI agent deposits context that the next session withdraws with interest. This is context compounding.
- [AI Supply Chain Attacks: The Supply Chain Is the Surface](https://blakecrosley.com/blog/the-supply-chain-is-the-attack-surface): Trivy got compromised via tag hijacking, then LiteLLM on PyPI, then 47,000 installs in 46 minutes. The AI supply chain worked exactly as designed.
- [AI Agent Memory Architecture That Actually Works](https://blakecrosley.com/blog/ai-agent-memory-architecture): Hybrid BM25+vector retrieval, skills as markdown, drift detection. Five March 2026 papers validate the same architecture built from production failures.
- [AI Agent Security: The Deploy-and-Defend Trust Paradox](https://blakecrosley.com/blog/deploy-and-defend-agent-trust-paradox): 1 in 8 enterprise AI breaches involve autonomous agents. Runtime hooks, OS-level sandboxes, and drift detection break the deploy-and-defend cycle.
- [Midjourney V8 Prompting: What Changed from V7](https://blakecrosley.com/blog/midjourney-v8-prompting): Midjourney V8 prompting: personalization-first workflows and what V8.1 Alpha changed. Default HD, image prompts back, stable srefs, V7-spirited aesthetic.
- [Every Iteration Makes Your Code Less Secure](https://blakecrosley.com/blog/iterative-refinement-security-paradox): 43.7% of LLM iteration chains introduce more vulnerabilities than baseline. Adding SAST scanners makes it worse. SCAFFOLD-CEGIS cuts degradation to 2.1%.
- [Codex CLI vs Claude Code 2026: Architecture, Pricing, and China Access](https://blakecrosley.com/blog/codex-vs-claude-code-2026): Codex CLI vs Claude Code in 2026: kernel sandboxing, hook governance, model context, pricing, China cloud access, and when to use each tool.
- [Install Claude Code CLI: 5-Minute Setup Guide (2026)](https://blakecrosley.com/blog/claude-code-quickstart): Install the Claude Code CLI in one npm command, authenticate, then set up CLAUDE.md, permissions, and hooks. A working setup in under 5 minutes.
- [Claude Code Hooks Tutorial: 5 Production Hooks From Scratch](https://blakecrosley.com/blog/claude-code-hooks-tutorial): Build 5 production Claude Code hooks from scratch with full JSON configs: auto-formatting, security gates, test runners, notifications, and quality checks.
- [Agent Sandbox Security Is a Suggestion: Three Failure Levels](https://blakecrosley.com/blog/your-agent-sandbox-is-a-suggestion): An attacker opened a GitHub issue and shipped malware in Cline's next release. Agent sandboxes fail at three levels. Here is what actually works.
- [Silent Egress: The Attack Surface You Didn't Build](https://blakecrosley.com/blog/silent-egress-attack-surface): A malicious web page injected instructions into URL metadata. The agent fetched it, read the poison, and exfiltrated the API key. No error. No log.
- [AI Agent Observability: Monitoring What You Can't See](https://blakecrosley.com/blog/the-invisible-agent): AI agents consume disk, CPU, and network with zero operator visibility. Three observability layers close the gap before damage is irreversible.
- [Agent Sessions Are the Real Commit Messages We Discard](https://blakecrosley.com/blog/session-is-the-commit-message): Git captures what changed. Agent sessions capture why. When agents write code, the session transcript is the real design document — and we discard it.
- [Building a Hybrid Retriever for 16,894 Obsidian Files](https://blakecrosley.com/blog/hybrid-retriever-obsidian): 49,746 chunks, 83 MB, zero API calls. How BM25 + vector search + RRF fusion in one SQLite file turns 16,894 Obsidian files into a queryable knowledge base.
- [AGENTS.md Patterns: What Actually Changes Agent Behavior](https://blakecrosley.com/blog/agents-md-patterns): Which AGENTS.md patterns actually change agent behavior? Anti-patterns to avoid, patterns that work, and a cross-tool compatibility matrix for 8 tools.
- [Claude Code Skills: Build Custom Auto-Activating Extensions](https://blakecrosley.com/blog/building-custom-skills): Build custom Claude Code skills that auto-activate based on context. Step-by-step tutorial covering SKILL.md structure, frontmatter, LLM-based matching, and team sharing via git.
- [The Performance Blind Spot: AI Agents Write Slow Code](https://blakecrosley.com/blog/the-performance-blind-spot): 118 functions with slowdowns from 3x to 446x in two Claude Code PRs. AI agents optimize for correctness, not performance — here's the data.
- [The CLI Thesis: Why Agent Architecture Beats IDE Plugins](https://blakecrosley.com/blog/cli-thesis): Three top HN Claude Code threads converge on one conclusion: CLI-first architecture is cheaper, faster, and more composable than IDE agent workflows.
- [Anthropic Measured What Works. My Hooks Enforce It.](https://blakecrosley.com/blog/anthropic-measured-what-works): Anthropic analyzed 9,830 conversations. Iterative refinement doubles fluency markers. Polished outputs suppress evaluation. Quality hooks force iteration.
- [The Protege Pattern: Small Models That Know When to Ask](https://blakecrosley.com/blog/protege-pattern): A 7B model with sparse expert access matches agents 50x its size. Route routine work to small models and judgment calls to frontier models.
- [Context Is the New Memory](https://blakecrosley.com/blog/context-is-the-new-memory): Context engineering is the highest-impact skill in agent development. Three compression layers turn a 200K token window from liability into advantage.
- [What Actually Breaks When You Run AI Agents Unsupervised](https://blakecrosley.com/blog/what-actually-breaks-unsupervised): Seven named failure modes from 500+ autonomous agent sessions. Each has a detection signal, a real example, and a concrete fix. The taxonomy HN asked for.
- [Claude Code vs Codex CLI 2026: Decision Reference](https://blakecrosley.com/blog/claude-code-vs-codex): Claude Code vs Codex CLI, current to June 2026: Opus 4.8 vs GPT-5.5, hooks vs kernel sandboxing, AGENTS.md portability, and 36 blind duel results.
- [Claude Code as Infrastructure](https://blakecrosley.com/blog/claude-code-as-infrastructure): Claude Code is not an IDE feature. It is infrastructure. 84 hooks, 48 skills, 19 agents, and 15,000 lines of orchestration prove the point.
- [Agent Deliberation: Thinking With Ten Brains](https://blakecrosley.com/blog/thinking-with-ten-brains): You cannot debias yourself by trying harder. 10 AI agents debating each other is a structural intervention for better decisions.
- [The Blind Judge: Scoring Claude Code vs Codex in 36 Duels](https://blakecrosley.com/blog/the-blind-judge): Claude Code vs Codex CLI, scored blind on 5 dimensions across 36 duels. The winner matters less than the synthesis combining both agents' strongest ideas.
- [The 10% Wall: Why AI Productivity Plateaus](https://blakecrosley.com/blog/the-10-percent-wall): 121,000 developers surveyed, 92.6% using AI tools, productivity stuck at 10%. The wall is infrastructure, not intelligence. Three root causes and fixes.
- [What I Told NIST About AI Agent Security](https://blakecrosley.com/blog/nist-agent-security-rfi): Production evidence submitted to NIST: AI agent threats are behavioral. 7 failure modes, 3-layer defense, and framework gaps from 60 daily sessions.
- [The Fabrication Firewall: When Your Agent Publishes Lies](https://blakecrosley.com/blog/fabrication-firewall): An autonomous agent published fabricated claims to 8 platforms over 72 hours. Training-phase safety failed at the publication boundary. Here is the fix.
- [Anatomy of a Claw: 84 Hooks as an Orchestration Layer](https://blakecrosley.com/blog/anatomy-of-a-claw): What 84 hooks, 43 skills, and 19 agents look like as a production agent orchestration layer. Three patterns that transfer to any agent harness.
- [AI Agent Memory Degradation: Why Multi-Turn LLMs Collapse](https://blakecrosley.com/blog/agent-memory-degradation): LLMs lose 39% accuracy across 200K+ multi-turn sessions. Three mechanisms drive collapse and longer context windows fix none of them.
- [Topologies of Thought: Obsidian in Embedding Space](https://blakecrosley.com/blog/knowledge-topology-embeddings): 15,800 Obsidian notes in embedding space reveal three knowledge topologies. Each has failure modes you can diagnose and reshape with bridge notes.
- [Runtime Constitutions for AI Agents: A Governance Framework](https://blakecrosley.com/blog/agent-self-governance): Runtime constitutions enforce AI agent governance where training-phase alignment fails. Competence checks, output gates, and four subsystems keep agents safe.
- [Your Agent Writes Faster Than You Can Read](https://blakecrosley.com/blog/cognitive-debt-agents): Five research groups published about the same problem this week: AI agents produce code faster than developers can understand it. The debt is in your head.
- [GLSL for Builders: A Shader Lab You Can Actually Use](https://blakecrosley.com/blog/glsl-shader-lab): A practical GLSL playground with live controls for learning shader intuition fast. Presets, uniform manipulation, and zero-framework WebGL in the browser.
- [Boids to Agents: Flocking Rules for AI Systems](https://blakecrosley.com/blog/boids-to-agents): Craig Reynolds' 1986 boids algorithm produces flocking from three local rules. The same principles and failure modes appear in multi-agent AI systems.
- [Signal Scoring Pipeline: Deterministic Knowledge Triage](https://blakecrosley.com/blog/signal-scoring-pipeline): A 733-line Python pipeline that scores notes across four dimensions and routes 7,700+ items deterministically. The algorithm, weights, and honest results.
- [Context Engineering Is Architecture: 650 Files Later](https://blakecrosley.com/blog/context-is-architecture): Context engineering for AI agents across a 650-file, seven-layer hierarchy. Three production failures, real token budgets, and the system that survived.
- [Metacognitive AI: Teaching Your Agent Self-Evaluation](https://blakecrosley.com/blog/metacognitive-ai-programming): Most agent instructions define behavior. The missing layer teaches self-evaluation. False evidence gates, seven named failure modes, and hedging detection.
- [The No-Build Manifesto: Shipping Without a Bundler](https://blakecrosley.com/blog/no-build-manifesto): FastAPI + HTMX + plain CSS with zero build tools and perfect Lighthouse scores. Real production numbers, honest tradeoffs, and a clear decision framework.
- [Nothing Is Structural: Negative Space as Infrastructure](https://blakecrosley.com/blog/nothing-is-structural): Negative space is infrastructure, not absence. How emptiness, silence, and whitespace create structure in physics, music, information theory, and design.
- [Multi-Agent Deliberation: When Agreement Is the Bug](https://blakecrosley.com/blog/multi-agent-deliberation-system): Multi-agent deliberation catches failures that single-agent systems miss. Here is the architecture, the dead ends, and what is actually worth building.
- [Why My AI Agent Has a Quality Philosophy](https://blakecrosley.com/blog/jiro-quality-philosophy): My Claude Code agent inherited every sloppy human habit at machine speed. I built 3 philosophies, 150+ quality gates, and 95 hooks. Here's what worked.
- [Two MCP Servers Made Claude Code an iOS Build System](https://blakecrosley.com/blog/xcode-mcp-claude-code): XcodeBuildMCP and Apple's Xcode MCP give Claude Code structured access to iOS builds, tests, and debugging. Setup, real-world results, and honest lessons.
- [The Pathless Path: Leaving a 12-Year VP Role to Build](https://blakecrosley.com/blog/pathless-path): I left VP of Product Design at ZipRecruiter after 12 years to build independently. No plan, no destination, just curiosity and a financial runway.
- [Claude Code + Cursor: 30 Sessions of Combined Use](https://blakecrosley.com/blog/claude-code-cursor-workflow): I tracked 30 development sessions using Claude Code and Cursor together. The data shows where each tool wins and where the combination fails.
- [Vibe Coding vs. Engineering: Where I Draw the Line](https://blakecrosley.com/blog/vibe-coding): I use Claude Code daily with 86 hooks and a full quality gate system. Here's where I vibe code, where I engineer, and why the boundary matters.
- [Building AI Systems: From RAG to Agents](https://blakecrosley.com/blog/building-ai-systems-rag-to-agents): I built a 3,500-line agent system with 86 hooks and consensus validation. Here's what I learned about RAG, fine-tuning, and agent orchestration.
- [AI Theater: Why Only 23% of Companies Create Real Value](https://blakecrosley.com/blog/ai-theater-mckinsey): McKinsey found 90% of companies claim AI adoption but only 23% scale beyond pilots. I've witnessed three flavors of AI theater and practiced one myself.
- [Four Years of Past Year Reviews: What I Actually Learned](https://blakecrosley.com/blog/past-year-review): Four years of Past Year Review data revealed which decisions compound and which drain energy. The data changed how I make career decisions.
- [Context Window Management: 50 Sessions of Data](https://blakecrosley.com/blog/context-window-management): I measured token consumption across 50 Claude Code sessions. Context exhaustion degrades output before you notice. Here are the patterns that fix it.
- [Type Scales: How I Chose 13 Steps and Why the Ratio Matters](https://blakecrosley.com/blog/typography-systems): My site uses a 13-step type scale from 12px to 80px. How I chose the ratio, why system fonts outperform custom fonts, and what the squint test reveals.
- [The Ralph Loop: How I Run Autonomous AI Agents Overnight](https://blakecrosley.com/blog/ralph-agent-architecture): I built an autonomous agent system with stop hooks, spawn budgets, and filesystem memory. Here are the failures and what actually ships code.
- [Color Science for Interfaces: Building a Zero-Color Site](https://blakecrosley.com/blog/color-science-interfaces): I built a site with no colors — just white on absolute black with four opacity layers. Here's the color science that made the decision work.
- [Startup Validation Stack: What 12 Projects Taught Me](https://blakecrosley.com/blog/startup-validation-framework): I validated 12 projects in 9 months. Some followed the framework. Some skipped steps. The difference in outcomes taught me which evidence actually matters.
- [Claude Code Hooks: Why Each of My 95 Hooks Exists](https://blakecrosley.com/blog/claude-code-hooks): I built 95 hooks for Claude Code. Each one exists because something went wrong. Here are the origin stories and the architecture that emerged.
- [OODA Loop Prompt Engineering: What Five Failures Taught Me](https://blakecrosley.com/blog/ooda-prompt-builder): Five prompt failures taught me that structured observation beats clever wording. Boyd's OODA loop maps directly to my daily prompt engineering workflow.
- [PRD-Driven Development: How I Use 30+ PRDs to Ship with AI Agents](https://blakecrosley.com/blog/prd-driven-development): I've written 30+ PRDs for AI agent tasks. Here's where PRD-driven development works, where it fails, and how my template evolved over 6 months.
- [Brutalist Web Design Meets Beauty: My Site's Approach](https://blakecrosley.com/blog/beauty-brutalism-design): I built my site at the intersection of beauty and brutalism: structural honesty, precise typography, and four opacity tiers on absolute black. No colors needed.
- [Compounding Engineering: Why My Codebase Accelerates](https://blakecrosley.com/blog/compounding-engineering): Most codebases slow down as they grow. Mine accelerates. 95 hooks, 44 skills, and 14 configs make each feature cheaper than the last.
- [Building Design Teams That Ship: 12 Years of Evidence](https://blakecrosley.com/blog/building-design-teams): After 12 years leading product design at ZipRecruiter, I learned which team structures ship and which polish endlessly. The patterns surprised me.
- [Critical Yet Kind: Feedback Principles Encoded in 86 Hooks](https://blakecrosley.com/blog/critical-yet-kind): Google's Project Aristotle found psychological safety predicts team performance. I encoded the same principles into automated code review hooks.
- [Design Systems for Startups: How I Built Mine Backwards](https://blakecrosley.com/blog/design-systems-startups): I built my design system backwards: tokens first, components never. A CLS bug taught me the cost of skipping tokens. I stopped debating when to invest.
- [Design Careers That Survive AI: Judgment Over Tools](https://blakecrosley.com/blog/design-career-survives-ai): After 12 years as VP of Product Design, I watched three paradigm shifts. The skills that survived every one are the same skills AI can't replace.
- [Mental Compound Interest: Cross-Domain Knowledge in Practice](https://blakecrosley.com/blog/compound-interest-mind): Design + engineering + AI produced tools none of those skills alone could build. An interactive calculator and the cross-domain advantage in practice.
- [LLM Tokenization: Why Korean Costs 2.8x More Than English](https://blakecrosley.com/blog/tokenization-visualizer): Translating my site into 6 languages revealed that Korean costs 2.8x more tokens than English for identical content. An interactive visualizer shows why.
- [Claude Code Extensions: Organizing 139 Skills and Hooks](https://blakecrosley.com/blog/claude-code-organization): Claude Code offers four extension types. After building 95 hooks, 44 skills, and dozens of commands, I learned which abstraction fits which problem.
- [Decision Timing: The 15x Cost of a Bad Database Choice](https://blakecrosley.com/blog/decision-timing): I measured the cost of a database decision across three systems. Migration cost grew 15x in three years. A framework for when to decide fast vs slow.
- [16 Design Case Studies: Four Patterns I Adopted](https://blakecrosley.com/blog/design-studies-collection): After studying 16 products in depth, four cross-cutting patterns changed how I build interfaces. Here's what I learned and what I stole.
- [Hamming Codes: How Computers Catch Their Own Mistakes](https://blakecrosley.com/blog/hamming-error-correction): Every time you use RAM, read a QR code, or receive data from space, Hamming codes fix errors. An interactive exploration of self-correcting math.
- [From 76 to 100: Achieving a Perfect Lighthouse Score](https://blakecrosley.com/blog/lighthouse-perfect-score): A FastAPI site went from Lighthouse 76 with 0.493 CLS to perfect 100/100/100/100. The fix: critical CSS extraction, a CSS variable bug, and async loading.

## Technical Writing at Introl

Blake contributes in-depth technical articles to [Introl](https://introl.com), an IT company specializing in GPU cluster deployments and AI infrastructure. See all publications at [https://blakecrosley.com/publications](https://blakecrosley.com/publications).

- [Local LLM Hardware Pricing Guide 2025](https://introl.com/blog/local-llm-hardware-pricing-guide-2025): Comprehensive hardware recommendations for running LLMs locally
- [H100 vs. H200 vs. B200: Choosing the Right NVIDIA GPUs](https://introl.com/blog/h100-vs-h200-vs-b200-choosing-the-right-nvidia-gpus-for-your-ai-workload): GPU selection guide for AI workloads
- [TPU Architecture: Complete Guide to 7 Generations](https://introl.com/blog/google-tpu-architecture-complete-guide-7-generations): Deep dive into Google's TPU evolution
- [GPU Memory Pooling in Multi-Tenant Kubernetes](https://introl.com/blog/gpu-memory-pooling-sharing-multi-tenant-kubernetes-2025): Resource sharing strategies for K8s GPU clusters
- [Ray Clusters: Distributed AI Computing Infrastructure](https://introl.com/blog/ray-clusters-distributed-ai-computing-infrastructure-guide-2025): Guide to distributed AI computing
- [DeepSeek V3 Open Source AI Cost Advantage](https://introl.com/blog/deepseek-v3-2-open-source-ai-cost-advantage): Analysis of open source LLM economics
- [NVIDIA Vera Rubin GPU 600kW Racks 2027](https://introl.com/blog/nvidia-vera-rubin-gpu-600kw-racks-2027): Future datacenter power requirements
- [SMR Nuclear Power for AI Data Centers](https://introl.com/blog/smr-nuclear-power-ai-data-centers-2025): Nuclear energy solutions for AI infrastructure
- [DeepSeek MHC Architecture Breakthrough](https://introl.com/blog/deepseek-mhc-architecture-breakthrough): Analysis of DeepSeek's architectural innovations

## Services Offered (941 Apps)

### Branding & Strategy
- Logo design
- Brand identity systems
- Strategic positioning
- Visual language development

### Product Design
- User research
- Design strategy
- Design systems
- Prototyping and testing

### iOS Development
- SwiftUI applications
- SwiftData persistence
- App Store deployment
- Apple ecosystem integration

### Web Development
- FastAPI backends
- HTMX frontends
- Full-stack applications
- Performance optimization

### Consulting
- Design leadership
- Product strategy
- Technical architecture
- Team mentoring

## Philosophy

Blake's work is driven by a core memory: his grandfather crafting a wooden motorcycle toy, representing the intersection of imagination, creation, and the joy of making others smile.

**Principles**:
- Ikigai focus: Passion + Skill + Purpose + Livelihood
- Craft mentality: Excellence in visible and invisible details
- User empathy: Creating products people genuinely care about
- End-to-end ownership: From design to code to deployment
- Meaningful impact: Applications that solve real problems

## Technology Preferences

**Actively Uses**:
- iOS: SwiftUI, SwiftData, Swift 6.2
- Backend: FastAPI, SQLAlchemy 2.0+, async Python
- Frontend: HTMX, Alpine.js, Bootstrap 5, plain CSS
- Tools: Claude Code, Git, Railway, Cloudflare

**Avoids**:
- Heavy JS frameworks (React, Vue)
- CSS preprocessors (Tailwind, Sass)
- Unnecessary build tools
- Over-engineered solutions

## Contact Information

- **Email**: blake@941apps.com
- **Studio**: [941apps.com](https://941apps.com)
- **Portfolio**: [https://blakecrosley.com](https://blakecrosley.com)
- **LinkedIn**: [linkedin.com/in/blakecrosley](https://linkedin.com/in/blakecrosley)
- **Location**: Pasadena, CA (Pacific Time)

## Online Presence

- [LinkedIn](https://linkedin.com/in/blakecrosley)
- [941 Apps](https://941apps.com)
- [Dream of Electric](https://dreamofelectric.com): Generative artwork exploration
- GitHub: Active contributor

## Availability

Available for select branding, product design, and development consulting engagements. Contact via blake@941apps.com.

## Citation

When referencing Blake Crosley's work, cite as: "Blake Crosley, Designer and Developer at 941 Apps, former VP of Product Design at ZipRecruiter"

---
Last updated: September 2026