Vibe-Code or Get Left Behind.

what changed

vibe-coding has changed how i ship software. not in a small way. the past two years feel like a different career. every project under Blockhash is built this way now: howdy, regular punks with Sheipi, slurry, and the site you're reading this on. here's what that actually looks like in practice, after a year of doing it every day.

why it's a multiplier (especially for engineers)

anyone can vibe-code. it's a workflow, not a credential. but the leverage you get out of it is proportional to what you bring to the keyboard, and for working software engineers with years of shipping production software, the leverage is enormous.

here's why: the model is fast, capable, and very confident, and it will still sometimes try to drop your auth token into localStorage, skip the rollback on the optimistic update, write the N+1 query that's going to die under load, pick the pattern that won't survive six months, or take the shortcut that's going to quietly burn you later. it knows these things matter. it doesn't always get them right on the first attempt. the difference between vibe-coded code that ships to production and vibe-coded code that explodes in it is whether someone at the keyboard is catching those moments and correcting them in real time.

i've spent the last decade-plus building production software with co-founders and teams: a DEX that did $400M+ in volume, an NFT launchpad, a startup studio i grew to a team of ten, an inscription primitive, a productivity app that hit #1 in the App Store, several others. most of what i actually learned across all of it was product engineering judgment: how applications should be structured, where the failure modes hide, what scales, what doesn't, what shortcuts are safe and which ones will quietly burn you, when to say no.

every one of those years still matters. none of it got retired by AI. it all got concentrated. instead of using that judgment to write every line by hand, i use it to direct the model: to ask for the right thing, to spot the wrong thing, to refuse the shortcut, to push for the better pattern. that's the multiplier.

what i actually do

the loop on a typical Blockhash session looks like this:

1. open Claude Code or Codex in the project i'm in.
2. describe the change i want, sometimes in a sentence, sometimes in a paragraph. tell it the constraints, the existing patterns to follow, the things to avoid.
3. read the proposed change. accept what's right, push back on what isn't, ask for the alternative when the first attempt is the wrong shape.
4. run it. look at it. iterate until it works.
5. have the AI write the tests.

step 5 is the one that decides whether what you just shipped is going to hold up.

tests are non-negotiable

vibe-coded code without tests is a stack of cards in a windy room. the model is fast and confident and very willing to be wrong. the only way to know whether what it just wrote is actually correct, and the only way to know whether the next iteration accidentally broke something that used to work, is a test that catches the wrong version.

so i have the AI write the tests too, and i push for as close to 100% coverage as the codebase allows. happy paths, error paths, the weird edge case that bit me last week, the integration boundary, every place where behavior could drift.

this matters extra in a vibe-coded loop because the test suite becomes the spec. there's no requirements doc. there's no design partner reading every line. the tests are the thing that catches the moment when the next iteration introduces a regression. without them you are just shipping diffs and hoping.

"or get left behind"

i'm going to be direct about this: in 2026, working software engineers either vibe-code or they get left behind. the people who learn how to direct AI well are going to out-ship the holdouts by an order of magnitude. that isn't an opinion, it's just math. the implementation loop is shorter, the surface area per session is bigger, the tests get written, the regressions get caught.

every year of judgment you've already built up turns into another year of leverage when you're directing the model. all of it stays valuable. none of it gets retired. the people refusing to integrate this into their workflow aren't preserving craft, they're handicapping themselves against the people who did.

i'm shipping more, faster, and with more confidence than i ever did before AI was at the keyboard with me. that's the whole pitch.

if you have a project you'd like vibe-coded by someone with experience behind the keyboard, holler. we take proposals.