Each Field Guide comes from actually building the thing, so you get the dead-ends and the fixes, not just the happy path. Work through one and you'll come out the other side with something running - not just a vague sense of how it works.
Field Guides
Field Guides go deeper than the blog - long-form, hands-on walkthroughs that take one topic from start to finish, gotchas and all. The kind of thing I wish I'd had the first time I hit the problem.
The Hypermedia Stack
Build one real app start to finish on Astro + Datastar + Directus — a hypermedia-first stack with a CMS backend, SSR endpoints that stream, and no SPA framework in sight.
Read guideEval-Driven Development
Build a real eval suite from zero with Evalite — deterministic checks, LLM-as-judge, and the data flywheel that turns user feedback into a system that improves itself. The unit tests for probabilistic software.
Read guideContext Engineering: The Craft of AGENTS.md
A build-along on writing, structuring, and evolving the context files — AGENTS.md, CLAUDE.md, constitution.md — that steer coding agents. From a blank file to a living system that compounds every cycle.
Read guideRunning the Fleet: A Field Guide to Multi-Agent Orchestration
You built one agent that knows you cold — its own personality, a memory that survives, skills it runs your way. It's a great employee. It's also still one employee, doing one thing at a time, waiting on you to hand it the next task. This guide is about the next move: turning that single agent into a coordinated fleet that plans, executes, and monitors real goals while you supervise instead of operate. It's the deep-dive sequel to [Building Your Agentic OS](/guides/building-your-agentic-os) — where that guide ended by pointing at the horizon, this one walks the whole distance. We build it on Hermes, because Hermes already ships the hard parts: profiles (every agent a full citizen with its own identity and memory), a durable kanban board that coordinates them, a decomposer that routes a dropped-in goal to the right specialists, and a way to package a whole agent as a git repo and hand it to your team. Concrete throughout, honest about the sharp edges, and built so the foundation you already laid is exactly what scales up.
Read guideBuilding Your Agentic OS: A Field Guide
Two people can use the exact same AI agent and get wildly different results. It's almost never the prompting. One of them built a system underneath the tool — a layer that gives the agent a persistent identity, a real memory, and a set of skills it runs the same way every time — and the other is still re-explaining themselves at the start of every session. This is a field guide to building that system, in three moves. First, the OS itself: a plain-files architecture you can stand up this afternoon on whatever agent you already use, built around three pillars — personality, memory, and skills. Second, the pivot — graduating that static setup onto Hermes, Nous Research's open-source, self-hosted agent, so the files stop being a brief you read aloud and become a teammate that runs on its own. And third, where it's all heading: coordinating many agents to plan, execute, and monitor real goals, with the orchestration, shared memory, and governance that make a true agentic OS. Everything here is portable by design, and you build it one working piece at a time — starting with a single agent that actually knows you.
Read guideThe 70/30 Engineer
The machine does about 70% of the typing now. That part is real, and it's not going back in the box. But the work that's left — guiding the agent, verifying what it produces, and owning the result — is the other 30%, and it turns out that 30% is the entire job. This is a field guide to working that way on purpose: a real, adoptable workflow for coding with agents, built on the AC/DC loop (Guide, Generate, Verify, Solve), grounded in what a year of agentic development actually taught the industry — the wins, the data, and the failure modes nobody likes to talk about. It's for the engineer who wants to be faster without shipping 1.7x more bugs to prove it.
Read guideThe AI-Era Fractional CTO's Field Guide
"Fractional CTO" has become one of those titles that means everything and nothing. If you're a founder, it's often unclear what you're actually buying — a part-time CTO? a fancy consultant? a cheaper hire? And if you're an experienced engineer, it looks like an appealing way out of full-time employment, but with no real map for how to do it well. This guide is for both of you — a straight, advisory look at what the role actually is, when a company needs one, what it costs in 2026, and the AI and agentic-team leadership that increasingly defines the job.
Read guideMigrating from HTMX + Alpine to Datastar: A Field Guide
For about two years, my default stack for interactive server-rendered apps was HTMX for the network and Alpine.js for the sprinkles of client state. It worked. It also meant I was running two libraries that didn't know the other existed, and I was the glue holding them together. I [wrote about why I finally switched to Datastar](https://rogerstringer.com/blog/why-im-migrating-from-htmx-alpine-to-datastar) — that post is the *why*. This one is the *how*. It's the guide I wish I'd had: a comprehensive, pattern-by-pattern map for moving an HTMX + Alpine app over to Datastar, with a bias toward Astro because that's where I live. If you've got an existing app and you're wondering whether the migration is a weekend or a quarter, the short answer is: smaller than you think, and you can do it one feature at a time. Let's get into it.
Read guideGuide to datastar with Astro
Datastar is a hypermedia framework that gives you the backend reactivity of HTMX and the frontend reactivity of Alpine.js in a single, lightweight library. If you've been using HTMX and Alpine together, you know the dance: HTMX handles your server requests and DOM swaps, Alpine handles your client-side interactivity, and you're constantly context-switching between two different mental models. Datastar unifies both into one cohesive system using standard `data-*` HTML attributes and Server-Sent Events (SSE). ### One library to rule them all. In this guide I'll walk you through the building blocks of Datastar, show you how it compares to the HTMX + Alpine combo you already know, and demonstrate how to build interactive web applications with Astro on the backend. I will assume you're familiar with HTMX and Alpine.js concepts. Learn more on the official website at [https://data-star.dev](https://data-star.dev) and check out the [getting started guide](https://data-star.dev/guide/getting_started).
Read guideMastering Directus
Directus has quietly become the first thing I reach for on almost every project — and not just as a headless CMS. Point it at a Postgres database and you get an instant REST and GraphQL API, a genuinely nice admin app your non-technical teammates can actually use, granular permissions, file handling, automation, and realtime — without writing a line of boilerplate. I rarely start an app these days without standing up Directus at some point. This is the guide I'd hand a competent developer who's never run Directus in anger: how to self-host it properly with Docker and Railway, how to model your data, how to lock it down, and how to ship real apps on top of it. _This is a living document and will be updated as Directus updates_
Read guideThe Product Engineer's Guide to AI-Powered Development Workflows
It's 3 AM, and you're staring at a production issue that's affecting 15% of your users. The error logs are cryptic, the stack trace points to three different microservices, and your team lead is asking for an ETA on the fix. Six months ago, this would have meant hours of debugging, context switching between monitoring tools, and probably a very late night. But tonight is different. You paste the error details into Claude, describe the user impact, and within minutes you have a clear diagnosis: a race condition in your payment processing service triggered by a recent deployment. More importantly, you have a tested fix and a deployment strategy that minimizes risk. What used to be a 4-hour debugging session just became a 20-minute resolution. This isn't science fiction—it's the new reality for product engineers who have learned to work alongside AI. After two decades in this field, building everything from travel platforms to AI automation tools, I've witnessed many technological shifts. But nothing has transformed my daily workflow quite like the AI revolution we're experiencing right now. The difference between traditional developers and product engineers has never been more important. While developers optimize for technical elegance, product engineers think backwards from user needs. We're the bridge between "what's technically possible" and "what actually solves problems." And AI doesn't just make us faster coders—it amplifies our ability to maintain that crucial product context while handling increasing technical complexity. In this guide, you'll discover how to build an AI-enhanced development workflow that spans from initial product discovery to deployment and monitoring. I'll share the specific tools and integrations that have transformed not just my productivity, but my ability to deliver user value faster and more reliably. You'll see real examples from recent projects, learn a framework for evaluating AI tools, and understand how to implement these changes without disrupting your team's existing rhythm. This matters more than ever because we're at an inflection point. Recent data shows that 76% of product leaders expect their AI investment to grow in 2025, and developers using GitHub Copilot report up to 55% productivity improvements without sacrificing code quality. But here's what the statistics don't capture: AI isn't just making us faster—it's making us better product engineers by freeing us to focus on the strategic, creative, and deeply human aspects of building products that people love. The developers who thrive in the next decade won't be those who resist AI or those who blindly adopt every new tool. They'll be the ones who thoughtfully integrate AI as a force multiplier for product thinking, user empathy, and creative problem-solving. If you're ready to become one of them, let's dive in.
Read guide