~ $ cd craft/writing && cat README.md

A craft
is shared.

I pair, I mob, I review by sitting beside someone rather than by leaving comments on their work — and I write it down, every Saturday. This is a way through the essays that are about the craft itself, in the order the ideas came.

Tests are documentation

The first thing I ever published was about this, and most of what came after grows from it.

• Why you should start writing tests as they were documentation
  It is great to suggest people write tests, but it is not enough.
• What If We Could Use The Code To Write Our User Stories?
  We see the code as the outcome of the user stories; what if we turned it around?
• Improve Your Testing #17: Write a Blog
  Why writing a post makes you better at writing for machines.

It is also why, in my course, the post is the test.

Improve Your Testing

A course in disguise, one Saturday at a time, from playing with a test to why a perfect one cannot exist.

1. Play With Your Tests
2. Real Developers Cheat
3. Challenge Yourself to Make the Smallest Possible Changes
4. Rediscover the ‘Why’ in Code Testing
5. Unlearn Software Development Myths to Learn Beyond Your Limits
6. The One Algorithm To Test Them All
7. The checklist of AAA
8. Keeping Your Tests Short and Clean
9. Learn From Testing Mistakes
10. Learn From Code Coverage
11. Breaking through the barrier of 100% code coverage
12. The F.I.R.S.T. Principles
13. When F.I.R.S.T. Principles Aren’t Enough
14. Mocks, Spies, and Stubs
15. Make Tests Human
16. Simplify Your Dependencies
17. Write a Blog
18. Make Your Tests Fast
19. The Infinite Test Conundrum

TDD with BDD-Gherkin

A small shop built test first, step by step, and what came out of it.

• How to TDD with BDD-Gherkin in JavaScript, then fetching from services, adding Redux, Redux first and fetching with Redux.
• Stop Using Gherkin as Scripting Language
  Common across QA teams, of dubious use, and far from what it is for.
• Presenting Gherkin Genie
  Your wish to quickly run Gherkin feature files in Jest is granted.

Pairing, mobbing, reviewing

• Pair Programming Is the Better Code Review
  What if the whole approach to code review is flawed?
• Why You Should Not Trust Pull Requests
  Something is wrong with them, and you can feel it.
• What If Most PR Comments Didn’t Need to Block the Merge?
  A pragmatic compromise, after years of arguing for reviewing together.
• Don’t Chat With Your AI. Mob With It.
  The chat loop makes you wait: put the agent in a loop over your files, and run several at once.

Clean code, and when to stop

• The Goal Of Clean Code Isn’t Perfect Code, but Maintaining Agility
  How over-engineering in the name of clean code hurts maintainability.
• Clean As You Cook, Clean As You Code
  The discipline of a restaurant kitchen that code needs just as much.
• Your Clean Code Might Be Someone Else’s Technical Debt
  Why patterns must adapt to the size of the team.
• Refactor All the Things All the Time
  Rewrite continuously whatever is necessary, instead of tiptoeing through the code.
• The Bowling Game Kata: refactor lessons, one and two, what to test and how to design.
• Asking the AI to clean your code is only half an instruction
  Why asking it to clean up is not enough, and what tells it when to stop.

TDD, as a practice

• TDD is Not a Stupid Idea, It is Brilliant
  Counterintuitive, and so one of the toughest things in programming to learn.
• Successfully adopting TDD in your team
  Its enemies, and the keys to bring it in.
• TDD is a Personality Development Framework in Disguise
  How a testing strategy quietly builds thinkers, doers and charmers.
• Scrum vs Extreme Programming: Was XP Right All Along?
  Could the most popular methodology be what holds teams back?

The rest, by subject, is in essays; what I have said about the same things out loud, agile among them, is in talks.