Most systems do not fail because code is hard. They fail because the next change has no clear owner. I build product software around the work that keeps it honest: clear boundaries, one source of truth, failure paths and rollback. I share the decisions, code and mistakes here.

After years of building software, I’ve learned that progress comes from showing up and making deliberate decisions, not waiting for motivation. Every day, we can ship something, improve what exists, or let things drift. One function. One refactor. One idea tested. Small improvements compound over time. Turning an idea into a real product takes consistency. Build, learn, improve, repeat. More on building and systems thinking: youtube.com/@pH7Programming

Indecision still makes a choice. For reversible decisions, set a deadline, choose the best option you have and learn quickly.

One thing I find fascinating about AI is how it changes the way we build software. You spend less time on execution and more time thinking about what should be built, why it matters, and how everything fits together. It almost feels like playing, but the quality of the outcome still depends on your judgement. AI can do the work. But knowing what work is worth doing is still on us.

A vision without a decision is decoration. Pick a direction, accept the trade-off and move far enough to learn something.

SVN gave us centralised version control. Git made distributed versioning mainstream. What’s next in the AI era? Code is becoming cheaper to generate. But the context, prompts, specifications and decisions behind it are becoming more valuable. Maybe the next evolution isn’t a better Git, but a way to version the entire process behind the software. Not just versioning code. Versioning context, intent and outcomes.

I’ve been advocating for Clean Code for over a decade. I’ve even published a guidebook, GoodJsCode, with my best practices for writing maintainable and scalable JavaScript - github.com/pH-7/GoodJsCode These days, I’ve been using those principles into my AI coding workflow with Claude Code and Codex. My custom AGENTS.md, rules and skills go beyond naming conventions. In fact, they help guiding architectural decisions, reduce duplication, challenge bad abstractions, protect existing code, enforce security boundaries and require meaningful validation. The goal isn’t just to generate code faster. The ultimate goal is to ensure that AI produces code I would be happy to review and maintain myself 👌

Gratitude isn’t pretending everything is fine. It’s noticing what is still good while life is difficult. Name three specific things today. 🙏

As a software engineer, your process matters more than any single tool. Tools change. A good process gives you a way forward, even when you don’t have all the answers. One principle I keep coming back to: understand the layer beneath the one you’re working with. Using a framework? Understand the language. Building with AI? Understand the model’s capabilities and limitations. The more you understand what’s happening underneath, the better decisions you can make on top.

SMART goals may be old, but vague goals still fail. Make the next target specific enough that you can tell whether you did it.

Anthropic built its own git replacement for agents, and they named it “Scion”! And it’s not really a surprise! Git was built for offline, distributed work, but agents are always online and committing in parallel, with Anthropic saying merges grew from 2,500 to 30k+ a day. It isn’t open source, but I hope these ideas make it into open tools so we can all adopt them for our agents! 🤖🤖🤖

Document the messy process, not only the polished result. It becomes proof, teaching material and a record of how you solved the problem. 🎥

4–7–8 Breathing A simple breathing technique to slow down, reset, and relax. 🫁 Inhale through your nose — 4 sec ⏸️ Hold — 7 sec 💨 Exhale through your mouth — 8 sec For an even simpler rhythm, try 4–4–4 breathing: Inhale 4 → Hold 4 → Exhale 4

┌─────────────────────────────────┐ │ PRINCIPLES OF A HAPPY LIFE │ │ │ │ 💖 CHERISH YOUR PEOPLE │ │ ↓ │ │ 🌳 PROTECT YOUR INDEPENDENCE │ │ ↓ │ │ 🎨 DO SOMETHING MEANINGFUL │ │ ↓ │ │ 💳 CHOOSE EXPERIENCES │ │ OVER POSSESSIONS │ │ ↓ │ │ 🤝 CONTRIBUTE YOUR TALENTS │ │ ↓ │ │ 👇 MODERATE YOUR AMBITIONS │ │ ↓ │ │ 💪 CARE FOR YOUR BODY │ │ ↓ │ │ 🤔 OBSERVE YOUR THOUGHTS │ │ │ │ ─────────────── │ │ │ │ LESS POSSESSING. │ │ MORE LIVING. │ └─────────────────────────────────┘

What should software engineers focus on in the AI era? Less coding. More: • Architecture & specs • Taste & judgement • Deep CS fundamentals • Quality & security AI can write the code. You still need to understand what you’re building and why. “You can outsource your thinking, but you can’t outsource your understanding.”

AI once bypassed an existing helper in my app. The code looked reasonable. It ignored how the app already worked. Before accepting a patch, check what it duplicates, bypasses or changes beyond the request. Working solo, I own the code AI leaves behind.

Code gets read far more than it gets written. Clear names, small functions and honest trade-offs are a gift to the next person.

Regret is to be punished twice. First, you suffer for the harm you have caused. Then, you suffer again because you regret having caused it. ┌──────────────────────┐ │ REGRET │ │ │ │ CAUSE HARM │ │ ↓ │ │ FIRST PUNISHMENT │ │ ↓ │ │ REGRET │ │ ↓ │ │ SECOND PUNISHMENT │ │ │ │ One action. │ │ Two sufferings. │ └──────────────────────┘ — after Spinoza