Reading Roundup: Choosing What to Own
When to take back control, when to let the framework handle it, and how to stay sane either way.
Hey there,
There’s a tension in every article this week between doing the work yourself and letting something else do it for you. That “something else” might be AI, Tailwind, a Stimulus controller, or a bunch of hand-wired Action Cable plumbing. The question isn’t whether to delegate. It’s whether you understand what you’re delegating, and whether you’re keeping the parts that actually matter to you.
The AI-Ready Redesign: How Spec-Driven Development Is Changing the Way Teams Build
Planet Argon on why AI-assisted development fails when teams skip discovery, and how spec-driven workflows like GitHub’s SpecKit force clarity before any code gets generated.
https://blog.planetargon.com/blog/entries/the-ai-ready-redesign-how-spec-driven-development-is-changing-the-way-teams-build
Live Background Job Progress in Rails 8.1 with Rails.event and Continuations
Code With Rails walks through a pattern for real-time job progress using three new Rails 8.1 primitives: Rails.event for structured events, framework-emitted Active Job lifecycle events, and ActiveJob::Continuable for cursor-tracked multi-step jobs.
https://codewithrails.com/blog/rails-live-job-progress/
Reusable Drag-and-Drop Image Preview in Rails
Rails Designer builds a custom HTML element for drag-and-drop image uploads with preview, replacing Stimulus controller boilerplate with a self-contained <image-upload> tag that handles its own file input, drag events, and form association.
https://railsdesigner.com/image-upload-element/
Moving Away from Tailwind, and Learning to Structure My CSS
Julia Evans on leaving Tailwind after eight years, what she took with her (the reset, the font scale, the colour palette as variables), and what she gained by going back to vanilla CSS with components, grid layouts, and esbuild.
https://jvns.ca/blog/2026/05/15/moving-away-from-tailwind--and-learning-to-structure-my-css-/
AI-Assisted Engineers Are Burning Out, Is This Fine?
Evil Martians on the hidden cognitive cost of AI-assisted coding: why delegating code generation to agents often means working harder, not less, and why the loss of the creative process itself is a bigger problem than most teams realise.
https://evilmartians.com/chronicles/ai-assisted-engineers-are-burning-out-is-this-fine
Quick notes and actionables
The Planet Argon article names something I keep seeing in practice: teams treating AI tools as a shortcut past the thinking phase, then wondering why they’re building the wrong thing faster. Their argument is that the discovery workshop has become the most strategically valuable step in a modern project, because AI amplifies whatever clarity (or confusion) you feed it. The SpecKit workflow is interesting, particularly the
/speckit.clarifystep, which forces you to surface underspecified areas before planning begins. In a legacy Rails app, “underspecified” usually means “undocumented behaviours that nobody consciously decided on.” The AI will find those gaps. That’s the point.The Rails 8.1 job progress piece is a proper walkthrough, not a teaser: The three primitives, Rails.event, structured Active Job events, and ActiveJob::Continuable, line up so that you get real-time user-facing progress without broadcast calls in the job body and without per-job Action Cable channels. The before_perform callback sets ambient context (user_id, job_id) so every event the framework emits automatically carries the data the subscriber needs to pick the right Turbo Stream. The caveats section is worth reading carefully. The enqueued event fires on the enqueueing thread before before_perform runs, so it won’t carry the context you set. And step.advance!(from: x) calls x.succ, not x, so the cursor is “next position to resume from,” not “last index processed.” If you’re on Rails 8.1, this pattern replaces a lot of hand-rolled progress tracking.
The custom element approach for image uploads is a good example of reaching for the simpler tool: The comparison with Stimulus is the useful bit. With Stimulus you need data-controller, data-target, and data-action attributes wired up across the markup. The custom element creates its own file input, finds the form, handles drag-and-drop, and manages preview rendering, all from a single
<image-upload>tag. It appends the hidden file input to the form element rather than to itself, which is the detail that makes it work with Rails params. If you’re already comfortable with Hotwire’s custom elements (turbo-frame, turbo-stream), this approach will feel familiar.The Julia Evans post is the one I’ll be sending around this week: She’s honest about what Tailwind gave her (a system for colours, fonts, spacing, and a reset she didn’t have to think about) and what it took from her (the ability to do things CSS can actually do, like grid-template-areas, that Tailwind can’t express). The component-based CSS structure she landed on, where each component gets a unique class and its own file, is simple enough to adopt without a framework. The responsive design section is particularly good. She replaced Tailwind’s media-query-heavy approach with CSS grid layouts using auto-fit and minmax that adapt without breakpoints. If you’ve been curious about writing vanilla CSS but weren’t sure how to structure it, this is a good starting point.
The Evil Martians burnout piece articulates something I’ve been feeling but hadn’t put into words: The productivity trap math is sharp. An AI-assisted engineer finishes in half the time but spends that time on cognitively demanding review and steering, not the meditative, satisfying process of writing code. Then, because it felt fast, they pick up the next task instead of stopping. The result: more high-intensity work, less fulfilment, no natural breaks. Their practical advice is worth the read, particularly the suggestion to protect “craft hours” where you code without agents, not because AI can’t handle it, but because you need to reconnect with the part of the work you actually enjoy.
From the week
I’ve been feeling the burnout from side projects recently, and the Evil Martians article landed at the right time.
The strange thing is that AI has made my side projects better than they’ve ever been. They look like real products now. They feel like real products. AI has enabled marketing in a way I’d never have been able to do on my own, generating content, posts, images, even video. And the coding side has been genuinely useful. I built a cookbook app that can scrape a recipe from a web page or an uploaded image. Previously that meant writing custom scrapers for each website, brittle code that broke every time a site changed its markup. Now it all goes through AI extraction, removing tonnes of flakey code and making the whole thing actually reliable.
But “better” comes with weight. When something looks and feels like a real product, you start treating it like one. There are users to think about, content to produce, features to prioritise. The side project stops being the thing you do to unwind and starts being another thing you manage.
Like everything, it’s a balance. The trick is probably noticing when the balance tips before you’ve already burned through whatever energy you had left.
On a completely different note, the Julia Evans post about leaving Tailwind resonated with me. I’ve pushed back hard on Tailwind in previous roles. My reasoning was always the same: the CSS under the hood is straightforward to write, and you’re not tying yourself to a vendor. The thing I always point people towards for thinking about CSS structure is CUBE CSS (cube.fyi). Composition, Utility, Block, Exception. It works with the cascade instead of against it, and it scales from tiny sites to large applications without needing a build tool to make it work.
Plenty to chew on this week. If you end up building something off the back of any of these, I want to hear about it. P.S. You can see everything I’ve been reading at dcyoung.dev/bookmarks.