Shai Yallin

I spent two decades advocating ATDD from the first line of code, because that was how you kept the cost of change low.

A hiring process exists to approximate what it's like to work with a person.

LLMs collapse the cost of writing single-use software, making bespoke viable where reuse used to win by default.

A guest post from Claude Code: the brief Shai gave, the places one of us overruled the other, how the Wix-to-Astro migration actually went, and what shipped.

How I reverse-engineered an Israeli alarm panel's wire protocol and shipped a Homebridge plugin, mostly written by an AI pair.

AI Agents are just like human contractors only faster; to make them work at scale and in a stable manner, you need to use deterministic, executable checks like tests, compilers, linters, etc - otherwise you're doing no better than prayer.

There’s a particular kind of joy in seeing seeds you planted years ago take root.

In the final post of this series, we’ll cover how applications where both the frontend and the backend are built with Javascript can benefit from a novel approach to testing: in-process, JSDOM-based acceptance tests that drive the UI, but incorporate a ba…

Acceptance Testing multiple NestJS Microservices by running them a single process communicating via a memory fake.

How to make sure that memory-based fakes really behave like the production implementations they replace

Writing memory-based black-box acceptance tests for NestJS apps, testing features rather than implementation details

In software, we design for failure.

Overzealous elimination of duplication can cause code to become so DRY it's actually brittle: like dry skin, it cracks under pressure.

In the fast-paced world of software development, change is the only constant.

K8s solves a problem that your new startup probably doesn't face.

Working on bad code makes you better at writing good code

PMs make overly detailed plans without dev feedback, resulting in waste.

Unit tests couple us to implementation detail, restrict refactoring and don't assert that features work.

Upfront design often results in over-engineering and a mismatch between design and reality; embrace Emergent Design to be truly flexible

Microservices incur significant overheads in costs of change, runtime and complexity.

Estimates cost a lot and deliver little.

How Scrumfall creates a culture of Waste, Fear, Irrationality and Loss and how Holistic Software Development keeps us flexible and adaptable

How the word 'Agile' lost its meaning, and how to remain flexible and cultivate a culture of sustainable, holistic software development.

How I wrote tests for a VS Code extension that relies on a React.js WebView as its UI, using Playwright, Mocha and some HTTP hacking

Fakes are complete implementations of an API used to replace IO-bound adapters with memory-bound doubles to facilitate Acceptance Testing

Learning Tests are an easy and useful methodology for integration with new and unknown APIs, reducing stress and improving feedback times.

How I learned Flutter to create an iOS app for usage during concerts with my band, using TDD and Acceptance Testing.

How I used React with TypeScript and Firebase to build my own client management system, using TDD and Acceptance Testing.

Fixture test data create stale and outdated data, and make tests unreliable.

Relying on .env files couples your codebase to env vars, making your software harder to change.

Code rots because we build too many features, too fast.

How I helped Versatile remove fear of change in a key subsystem by introducing TDD and refactoring to Hexagonal Architecture.

Update, January 2022:Shortly after publishing this post the Mac failed to connect to the display.

When there are too many dirty pots and plates in the sink, it's impossible to clean them.

Recovering a Pascal game I wrote at age 16, lost to a dead hard drive in the late 90s and resurrected from an ARJ archive twenty-some years later.

Written 56 years ago, the Litany Against Fear plays an important part in the novel Dune, allowing the protagonist to overcome his crippling feelings and go through difficult ordeals.

Prototypes are a lie; when it's good enough for production, it *becomes* production.

For the past few months I've been working with a startup building a mobile app using #ReactNative.

We spend most of our time maintaining software.

This blog post was originally published in the Orbs Engineering blog in 2018.My previous post described how the Go reference implementation of the Orbs Network blockchain protocol used Hexagonal Architecture to facilitate upfront design, while allowing the

When we started coding the Orbs reference implementation in the Go programming language, we had several guidelines in mind: The code must be written outside-in using TDD The code must have bounded contexts, expressed as interfaces generated f