Sean C Davis

try to work yourself out of a job i bet you'll like the result

i ditched descript and the quality of the content in the youtube shorts has leveled up

Heard a suggestion that we should separate the agents writing the tests from the agents writing the code. I like that a lot. Have the testing agent read the requirements to build the test, and then have the coding agent make the test pass without being allowed to adjust the tests themselves.

anyone who has ever deployed code that used a framework or other dependency had to have trust and delegate control to what was being shipped

this is an idea i'm still tinkering with, and it's getting better, but it was a rough start

we need to do a better job addressing the anxieties of folks afraid to lean in all the way exposure therapy and assumed ignorance aren't the right moves

Our job as engineers is to understand how a system works, identify the biggest problems, and fix them. That makes the job about the understanding. And that doesn't necessarily mean reading code.

Started sending telemetry events from CC sessions to my personal dev platform to better optimize usage. Not sure exactly how I'll get there yet. But I'm pleased to see how much data is available to study.

I've made some iterations to the sharing/working in public process, and I'm pleased with the progress after one week. Still not as active as I'd like to be, but I found a way to make time most days without getting too distracted. Trying to keep it rolling this week.

An ode to Arc (in the form of a Chrome extension).

I've tried to follow the single responsibility principle for side projects, but it's led to a lot of overlap. I'm going into a deep thinking session later this week to land on a new vision. I suspect it leans local-first, everything in the same space, focus and balance as core drivers.

While I'm rethinking the architecture around all my side projects, they largely revolve around this concept of helping me focus my time and keeping me, for the most part, in fewer applications. I don't think this is the final solution, but it feels like the core of where I'll be going.

Agents aren't getting worse at explaining, they are assuming you know more as they become more capable. I built a little skill to help communicate more effectively, and it's worked wonders in the last couple of weeks.

Zawinski's law: every program expands until it can do everything. Because every user asks one more thing. But now the program is my agent, and I am every user. But I also have to manage myself. And I am hard to manage. And thus, software is still hard to build.

The question that's becoming more important is not "what can this be?" but instead "what does this refuse to be?"

My "review-pr" skill was crawling on small PRs last week. The Codex QA subagents were re-running the entire CI suite because they couldn't see the status checks. Now the orchestrator hands them the checks. These are the little design smells that make the system stronger.

I built out a new team of agents with Slack as the source of truth for conversations, all around getting me to think deeper and post more frequently. The signal I'm looking for is wanting to take breaks throughout the day to do this work. Here's to yet another attempt!

Mods look like the right step forward. I'm going to tinker a bit this week — probably personal telemetry as the first use case. On the surface, excited about the potential, but worried about managing load order, especially when all this runs outside a sandbox.

The question that's becoming more important is not "what can this be?" but instead "what does this refuse to be?"

This is a nice summary. For the most part, it validates that the practice I have in preflight/autopilot is the right, balanced approach for models today. It's also a good reminder that writing things down is important, as long as it's the right stuff you're writing down.

Building evals from real data is a great idea, and being able to do it dynamically is huge! What I don't love is using one provider for all eval work. That's the beauty of AXIS, which could be wired into any pipeline you want to build.

Another quick example of using Raycast snippets to work more productively. This one is "\y" to get "/color yellow" for changing the color of a Claude Code CLI session.

I'm back to trying to keep up with social media again. Yet another approach that might not stick. This time I'm running everything through Slack. Demo coming soon!

I've really struggled with getting agents to draw diagrams well. So I built a little system to help. The Cubster API rasterizes images so that an agent can study what they drew and adjust.

I'm back to building agents for my personal agent system, and now it's running entirely serverless, without breaking the "determinism contract" that I originally created. This might be the one AI pattern I feel like I established earlier on that I still really like.

I did a little research into enjoying everyday life more. Satisfaction is an expectation gap, totally disconnected from objective quality. Like going to the movies — if a friend tells you it'll be great, it better be AMAZING or you're gonna be disappointed.

Cubster is quickly becoming almost like an agent toolkit. It doesn't really matter where my agents are if they need to perform some specific action, so we can have a centralized place for those things. You build it once and hone it over time.

Been honing the review-pr skill a bit this week by pulling from my autopilot skill. I'm finding that having an orchestrator dispatch multiple focused reviews from different models makes for stronger and more meaningful feedback.

I have too many projects. I definitely have to ditch some. But, I do feel like the model of how I want to run things is evening out, and if I can control the volume, I can build some cool (and useful) stuff.

This is fascinating! As much as I enjoy over-engineering solutions, there are a lot of useful cases for this.

I do think reviews are soon to go, at least in the form they've existed in. Largely because they're verifiable in a mostly deterministic way. That's the pattern. We level up what we work on, and then what we work on is the lower system that gives us the confidence to work at the higher level.

Claude Code doesn't tell you which model each subagent used, or how much of the work it did. So the `roster` skill runs a node script over the session and reports the whole crew.

To make releasing libs easier and more consistent, I rolled out a `/release` skill. Takes a lot of the thinking out of the process, and now I have a solid paper trail on the majority of my side work.

Been iterating on the /review-pr skill for a couple weeks. It helps me get oriented first, then digs into suggesting changes. I then read through all the code, adjust the comments, delete them, add my own, and submit the review. I've found it a great way to get up to speed on code quickly.

I've been into photography for many years, but never really learned the basics. Been using AI to help me iteratively learn the craft through specific assignments, grades, and editing notes. It's been a game-changer for me.

As agents get more capable, they almost know too much. Not all of that knowing needs to get passed on to the user. You can customize and harness most of it, but it takes a lot of effort.

Should major retailers be using WebMCP as their primary way for agents to talk to their site, even if it's less friction? Should we be prioritizing shipping public APIs and MCP servers instead?

A human skill is something you develop with practice over time. Agent skills are instructions, or behavioral recipes. Models are trained generally, and you can use skills to get specific results. I expect that pattern to stick around.

Years ago, managing a package and every app consuming it was enough work that it often made more sense to just build what you needed where you needed it. Now dependency updates, automation, tests — all of it is easy. Building your own personal abstractions is kind of a slam dunk.

There's an art to the craft of writing code, and some of it is an emotional response. That's fine. It's okay that a mass-produced picture frame costs $10 and the guy in my neighborhood charges hundreds to do framing. Both serve a purpose. Maybe code moves that way too.

I've been running a split where Claude writes the code and Codex reviews it, read-only. Two models with different training make different mistakes, so the reviewer catches things the author was blind to. Short video on how I set it up.

Was this on your Bingo card this week?

The only time I think ... I wish I worked for the government.