Jeff M.

DDD is the gold standard for complex domains. Everybody agrees. Evans was right. Vernon was right. The methodology works. But nobody wants to say the quiet part out loud. It was designed for teams. Knowledge crunching? That's two or more people in a room wrestling with ambiguity. Event storming? You need a wall, sticky notes, and a room full of people who disagree productively. Context mapping? That's a negotiation between teams. Every foundational practice in DDD assumes you're not alone. So what happens when you are? I'll tell you what happens. You adopt the tactical patterns without the strategic discipline. You define aggregates without doing bounded context analysis. You emit domain events without modeling policies or sagas. You build what looks like DDD from the outside but is really CRUD with fancier names. That's not a criticism. I've done it. You've probably done it. It's the rational response to a methodology that hands you the vocabulary but locks the practice behind a door marked "requires team." Here's the thing though — the patterns aren't the hard part. The books cover those. The conference talks cover those. What the books can't cover is the thing that happens when a senior practitioner points at your model and says "that boundary is wrong, and here's why." That transfers through osmosis. Through rooms. Through years of sitting next to people who've internalized things they can't articulate. If you don't have the room, whole layers of the methodology become invisible. Not wrong. Invisible. I wrote about why this matters and what it means for the thousands of architects building serious systems alone. https://lnkd.in/gNW7r-sn #DomainDrivenDesign #SoftwareArchitecture #DDD #SoloBuilder #AI

2

1 Comment

Engineers should constantly ask why, push back on bad ideas, and suggest alternatives. Some of our clients find it jarring at first. "Why is my developer questioning requirements?" Because that's what great engineers do. They think. They challenge. They improve. Unless, you want silent compliance and mediocre products 🤔

112

24 Comments

Funny watching big companies dunk on “vibe coded startups” like they just exposed something. “You can’t build stable systems like that.” “Won’t scale.” “Not production-ready.” No shit. That’s not what it’s for. You’re evaluating it like it’s supposed to replace your 200-engineer stack. Meanwhile, a 3-person team is using it to: test ideas in days get real user feedback iterate 10x faster than your roadmap allows Of course it looks messy to you. Your entire worldview is: stability process risk mitigation quarterly planning Their world is: speed learning what outcome takes less resistance to success Vibe coding isn’t trying to compete with enterprise systems. It’s a velocity engine. A test bench. A way to punch way above your weight *before* you earn the right to build it “properly.” So when a big company trashes a vibe-coded product for not being stable… it just shows they don’t understand the game being played. You’re optimizing for perfection. They’re optimizing for truth. And truth shows up faster than your next sprint cycle.

7

Any best guesses on how long until Claude Code can: 1. Fire up the browser (without needing the MCP configuration) to evaluate changes 2. Fully leverage the Chrome Dev Tools 3. Use the Ruby debugger I’m finding Claude Code is creating fixes that would have been too tedious or painful. The gap right now is testing and debugging.

10

4 Comments

If you're leading post-acquisition delivery and timelines are slipping while engineers quietly churn - this is the part no playbook prepares you for. The code was clean. The infra played nice. The teams were stuck. It's not tech debt. It's not tooling. It's not your roadmap. It's culture. Not the fluffy kind. The deep, invisible defaults - how teams think, prioritise, and act when things get hard. I've led 7 tech integrations, and here's what I've learned the hard way: Clean architecture won't save you... But aligning on these 8 cultural levers before you write a line of code will. 1. Value Hierarchy What wins when tradeoffs hit- velocity, stability, dev experience, or uptime? Tip: Build a tradeoff matrix. When priorities clash silently, resentment grows loudly. 2. Decision Velocity Are choices made in 2 days or 2 weeks? Tip: Codify a 48h SLA. Momentum dies in async purgatory. 3. Risk Tolerance What happens when things break—do teams freeze up or push ahead blindly? Tip: Define "safe to fail" by environment. Speed without guardrails ≠ agility. 4. Trust Defaults Can engineers ship solo, or must they get approval? Tip: Align on autonomy thresholds. Confusion here creates slowdowns and surprises. 5. Feedback Norms Slack thread or status deck? Blunt or buffered?  Tip: Co-create a feedback contract. Psychological safety isn't a given under pressure. 6. Technical Ownership Who owns what post-Day 1? Tip: Map systems and names. Ambiguity kills accountability. 7. Architecture Philosophy OSS-first or enterprise-preferred? Tip: Surface tooling biases early or risks future deadlocks over tech "religion." 8. Talent Signalling What does "good engineering" mean here? Tip: Align your definition. Otherwise, you'll hire (and reward) the wrong behaviours. Since aligning these levers: • Delivery overruns dropped 68% • Engineer retention rose to 91% • $3-5M preserved per integration Want the Cultural Alignment Scorecard? Comment "ALIGN" or DM me, and I'll send it over. Or forward this to your Head of Engineering. Let's fix what's stalling your integration before you write another line of code.

7

2 Comments

Six months of decisions that never got made. Here's what that actually cost. The plan was ready. The team was ready. Four exec forums. No outcome. Just “let’s review next quarter.” While everyone waited:: • $300K burned on idle contractors • A critical platform fell out of support • Senior engineers disengaged And still, progress was expected. Indecision is still a decision. It just hides the cost. What changed things wasn’t alignment. It was ownership. “We’re starting Monday unless someone stops it by Friday.” That single shift forced clarity. Delay was no longer invisible. Where is delay costing more that deciding right now? Most leaders don’t see the cost until it’s too late.

53

41 Comments

I was showing Ichi to about 120 building department staff when something interesting happened... During my webinar with CALBO last week I was demonstrating how we pull code sections and jurisdiction-specific requirements. Standard demo stuff. But these folks didn't only care about the speed (though yeah, turning 30-minute code searches into seconds is nice). They want to know, how can they trust it. This is where being able to show them the exact source of information matters. Makes total sense when you think about it. These are the people who carry the liability when something goes wrong. They're not going to trust some AI that spits out answers without showing its work. That's why we built Ichi to be completely transparent. The plan reviewers and inspectors I talked to after were genuinely relieved. Someone finally built tech that respects how they actually need to work. If you want to see what transparent AI for building departments actually looks like, I'll share the full demo link in the comments.

34

4 Comments

Developers weren’t just builders. They were gatekeepers. If you couldn’t code, you didn’t create. You waited. On engineering bandwidth. On roadmaps. On someone else’s priorities. Syntax was the wall. Know where the semicolon went? You shipped. Didn’t? You stood outside. That divide shaped more than workflows. It shaped status. Developers got the leverage. The scarcity gave them the power to decide what shipped and when. Everyone else adapted around them. It wasn’t about being smarter. It was about access — and access wasn’t evenly distributed. Some people were in the right rooms early, tripped into syntax, and built from there. Others never got the chance. That was the difference. But syntax was only the first kind of alpha. The second was quieter. Harder to see. More enduring. System knowledge. Knowing which database could survive Black Friday traffic. When to debounce vs. throttle. How to shard writes across regions. Not just writing code — architecting it. That’s the tacit layer. Built from war stories. Outages. Scaling pain. Years in the trenches. It’s still here. And it still matters. For now. I remember the first time I tried to shortcut it. I’d tell Claude what I wanted. It would spit out code. I’d paste it. It would break. I’d send back the error. It would try again. Loop by loop, something shifted. Reddit called it “copy-paste monkey.” They saw a hack. I saw a door opening. People who’d been locked out started building demos. Then products. Then real companies. The wall between “technical” and “non-technical” was never about intelligence. It was about translation. And now, translation is free. What matters now isn’t syntax. It’s clarity. How well you can think. Break things down. Iterate. That’s what the agent understands. And that’s what it rewards. The syntax advantage is gone. Developer privilege is flattening. System knowledge is next. Today, the agent can’t always choose the perfect database. But if you tell it the trade-offs, it will. If you give it context, it will architect with precision. That tacit edge still holds. But only for now. Soon, even that will be embedded. And leverage will shift again — to anyone who can think clearly enough to guide the machine. That shift isn’t coming. It’s here. And it’s not going away.

18

2 Comments

I often ask, “Why did you design it this way?” The strongest candidates don’t jump to tools — they explain the trade-offs. Example: “We used EMR for this pipeline because Glue jobs were hitting concurrency limits, and we needed better tuning control.” That one line shows experience, ownership, and context awareness. #DataEngineering #InterviewTips

4

A team member messaged me after a 4-hour call fixing dev issues. "I can't believe you were on that call." We have 100+ people at Genflow. I run a $100M agency. And I was right there debugging code with the team. It hit me how wrong most people get leadership. Everyone thinks being CEO means strategy sessions and vision boards. Wrong. Being CEO means being the captain who's still on the field. You show people how it's done by doing it alongside them. Not above them. The idea that you'll build a business and just work on "high-level stuff" while everyone else executes? That's not how you scale. You scale by staying close to the work. Understanding the actual problems. Building alongside your team. After 9 years of doing this, I've learned: The best CEOs aren't in corner offices. They're in the trenches when things break. They know the product inside out. They can still do the work if needed. Your team doesn't follow titles. They follow leaders who roll up their sleeves. What kind of leader are you trying to be?

45

16 Comments

Agents are the new apps. And they just went multiplayer. The software engineering landscape is undergoing a seismic shift. Google just dropped Firebase Studio. And it might just replace half the AI builder startups out there. You’ve probably seen tools like Lovable, bolt.new, Vercel's v0, or Cursor. They let you build AI-powered apps without writing much code. Describe what you want — boom — they create UIs, workflows, and automation for you. It’s fast. It’s smart. It’s changing how software is built. Now imagine that… backed by Google. What is Firebase Studio? Firebase Studio is Google’s new end-to-end app builder for AI-first products. It combines: ✅ UI generation ✅ Agent workflows (like AgentSpace) ✅ Firebase backend (auth, storage, hosting, etc.) ✅ Google’s best Gemini models AgentSpace is like a command center for AI agents. It lets you create multistep workflows, connect APIs, and manage how agents behave. Great for product teams prototyping internal tools, automations, or AI assistants. But it’s still pretty early-stage. Right now, Firebase Studio and A2A (Agent-to-Agent) are two separate moves from Google — but they are strategically aligned, and integration is very likely coming. You need to manage agents, instructions, tools, and sometimes code. Why this matters for product managers? → The barrier to building software is decreasing. → With Firebase Studio, a product manager can do what used to take a team. The AI agent is becoming the new app. Not just chat. Agents that do stuff: send emails, fetch data, run logic. Google wants to standardise agents across platforms. Their new Agent-to-Agent protocol (A2A) means your agents could soon talk to each other — across apps, tools, maybe even companies. Enter MCP: The USB-C for AI Anthropic’s Model Context Protocol (MCP) is an open standard that enables developers to build secure, two-way connections between their data sources and AI-powered tools. MCP is a standardised protocol designed to streamline the way AI models communicate with external systems, eliminating the need for custom integrations. With so many advancements happening rapidly, it’s challenging to keep up and navigate them within the realities of development. Yet, it has never been more exciting to be in the software engineering space. #AI #FirebaseStudio #ProductManagement #Innovation #TechTrends #MCP #A2A

16

1 Comment

The way we build software is about to fundamentally shift, and most teams aren't ready for it. I'm watching something fascinating happen right now. Software development agents are moving from "nice to have" to "embedded in your actual workflow." Not in some separate tool you have to context-switch into. We're talking agents that live in your IDE, your Slack, your CI/CD pipeline, your project manager. Everywhere you already work. Here's what gets me: this isn't about replacing developers. It's about removing friction. When you spot a refactor that needs doing, you don't context-switch and spend an hour on it. You delegate it right there and keep shipping. When an incident hits at 2am, your team doesn't start from zero. The agent is already in the war room with them. The real competitive advantage isn't going to teams with the fanciest AI. It's going to teams that integrate this into their actual development rhythm without disrupting it. The ones who treat agents as part of their workflow, not a parallel process. For founders building technical products right now, this is worth paying attention to. Your development velocity just became a core business metric in ways it wasn't before. What's your biggest bottleneck in your current development process? The thing that takes time but doesn't actually require your creative problem-solving? That's probably your first candidate for this kind of delegation.

1

You don’t need 10x engineers. You need cracked ones. (No, it doesn't mean broken as I initially thought 🤣) Had a great call last week with a founder and their on-site team about a critical engineering hire. They didn’t want someone “good.” They wanted someone cracked. At first, I literally had no idea what they were talking about (Thank you posthog 🦔.) Turns out it means engineers who demonstrate: Extreme ownership - they run towards problems and pull the team with them Enthusiasm for the craft - the kind that lifts the room even on rough days Care for quality and velocity - they think in systems, not just sprint tickets. They multiply the impact of those around them. This mindset can turn an “almost” project into one that gets deployed on time and shifts the needle for the business. At StreamYard, I saw it up close. The hires that changed everything weren’t just strong coders. We just didn't call it "cracked" at the time lol. They were energy givers (no energy vampires in startups 🧛) Engineers who took the mission personally. Engineers who others wanted to follow. Quick tip Don’t just ask: Can they do the work? Ask: Will they bring clarity, momentum and belief? That’s what cracked really means. If you're hiring now or have hired engineers in the past, how do you assess this? If you'd like to give a cracked engineer a shout-out, tag them in the comments for some props! Everyone loves a bit of positive recognition.....

11

This one might hurt a little. 👀 I’m being honest. 🫡 I’ve worked in teams that said, “We’ll add tests later.” Later never came. —————- ❌No TDD Feature starts fast. PR looks big and impressive. Everyone claps. Then… One small change breaks three modules. QA finds regression. Hotfix goes out. Another thing breaks. Now the same feature costs 3x the effort. Speed at the start. Stress at the end. —————— ✔️With TDD Start with a failing test. Write just enough code to pass. Refactor safely. Repeat. It feels slower. It feels uncomfortable. It forces you to think. But here’s what I’ve seen: Fewer surprises. Cleaner design. Refactoring without fear. Confidence during releases. —————— TDD isn’t about loving tests. It’s about respecting the future version of yourself who will maintain this code. From my QA lens, the difference is clear: Without TDD → QA becomes a damage controller. With TDD → QA becomes a quality partner. And that shift changes everything. Agreed? Learn With Psudo #TestDrivenDevelopment #TDD #SoftwareDevelopment #QualityEngineering #ShiftLeft #AutomationTesting #Agile #DevOps #CleanCode #ContinuousIntegration #SoftwareTesting #TechLeadership

3

I think the future of development won't be 2x,5x,10x but how creative and parallel can you effectively go without bad output quality. Maybe we call this being a 2p or 5p engineer. It will probably involve managing many agents and layering additional agents on those for quality, company standards, security, compliance, CI/CD. This is the current trend in a lot of the literature and hints from hot AI devs being released to the public. I see inexperienced developers complaining that these AI tools are not good. I think that's wrong. They are amazingly good. The tools enhance the common experienced design patterns of small file sizes, and limited context per file that requires a lot of discipline. This image was generated with Comfy UI using Flux Kontext Dev

6

Hiring engineers for hard operational problems is different. Most candidates can write clean code. Fewer can sit with a dispatcher at 7am and understand why their shift planning breaks down. Fewer still can go back to the codebase and design something that actually works in production with those constraints. What I look for at Mirage Metrics is not just skill with Python, SQL, or distributed systems. It is a willingness to go into environments that are messy, sometimes chaotic, and keep digging until the real bottleneck shows up. That can mean inventory mismatches hidden in Excel, planning rules written on a whiteboard, or API endpoints that return inconsistent data depending on who queries them. The best engineers I have worked with are the ones who do not flinch at this. They treat debugging a customs declaration pipeline with the same seriousness as debugging a memory leak. They know that solving “boring” problems in data quality or workflow mapping is what unlocks everything else. On the technical side, I test for clarity. Can someone explain the trade-offs between running a model via an API versus hosting it on GPUs without getting lost in jargon. Can they design a schema validator that will still make sense six months later when requirements change. Can they write glue code that is robust, not fragile. On the personal side, I look for stamina. These projects are rarely about building a shiny feature in isolation. They require iteration with operators, late-night debugging of OCR failures, and the patience to integrate into legacy systems that were never designed for AI. If you want to work on AI for logistics, manufacturing, or mining, the question is not only whether you can code. It is whether you can hold your ground in the real world, in front of the people whose work depends on your system. That is the bar.

17

5 Comments