Shawn Fitzgerald

What a Saturday morning flying habit taught me about releasing code. When you fly, you never skip the checklist. It doesn’t matter how experienced you are, discipline and process keep things safe. That mindset changed the way I think about software releases. Instead of treating them like high-stress events, they should be routine operations backed by preparation, clear procedures, and trust in the system. I wrote about the parallels between aviation and software engineering in my latest piece for Finance Magnates. Read it here: https://lnkd.in/eAcCFxhw

37

Most bad experiences with AI coding tools trace back to the same mistake: a vague first prompt. "Build a productivity app" forces the AI to guess your stack, your features, and your design choices. Then you spend the next 3 hours fixing decisions that should have been specified upfront. A complete first prompt in Bolt.new has five elements: application purpose, tech stack, feature list with behavioral detail, design constraints, and explicit exclusions. That last one is underrated. Without exclusions, Bolt adds features based on what similar apps typically have — not what you asked for. A simple "DO NOT INCLUDE: dark mode, file attachments, multi-user features" saves you from cleaning up well-intentioned scope creep. I wrote the full playbook — from first prompt structure to Kiro steering files to the iterative patterns that keep multi-session projects consistent. Full guide → https://lnkd.in/gm5eMt78

1

Last week on the flight back from Cupertino I put together a one pager to capture ideas for an SDLC for Agentic development. While we are operating as Steve Yegge calls Level 8, a clear area of investigation for us was how to ensure that product and operational quality doesn’t suffer when inbound code velocity increases 10x. I was sure that others have been thinking about the same.. and looking around I ran head long into a controversy around an adjacent issue here: https://lnkd.in/efqSYa9k For me the controversy of accepting or rejecting agent generated code is actually not the point. Developers have been using code they didn’t write for decades.. ever since the first copy-pasta from stack overflow. The controversy is how to maintain the code and operational bar while keeping up with inbound PR velocity that eventually comes with agentic software development.  How do repo maintainers and code reviewers in general validate code without becoming bottlenecks? How do enterprises still ensure that their staff can support code they didn’t write? The answer to both questions above might come from two perspectives.. The AI native community might say both of these tasks should be done by AI and not humans. We just need to build tooling, knowledge bases, and prompts that guide the stochastic machinery to do this automatically and converge correctly. The skeptics might say that it’s the human who would eventually take responsibility for a large scale outage and need to be able to support products they are responsible for. That eventual convergence is not guaranteed and then what is our backup plan? The approach I’m sure is somewhere in the middle of the two perspectives. What do you think it is? Annie Vella Boris Cherny Richie Bielak Dan Adler Michael Dubno Steven Willis Steve Yegge Constantin G Jim Roskind Tim Lindholm Rinaldo DiGiorgio Ippokratis Pandis Marvin Theimer Doug Terry

46

11 Comments

Validating Risk Scores at the Source Our HCC-In-FHIR package keeps getting more robust every day. Though I'll admit - the name's a bit misleading now since we've expanded beyond just FHIR (see the figure below). The package now handles three primary formats: X12 837, FHIR, and custom formats. But here's the key: it calculates CMS HCC risk scores directly from your source data. Why does this matter? Every data transformation step between your source data and final risk scores creates two problems: - Delays in getting actionable insights - Information loss along the way Anyone who's tracked a single claim from practice to CMS encounter data knows exactly what I'm talking about. The amount of data that gets lost from source to destination is staggering. By calculating risk scores directly from the data you receive from clearinghouses and submit to CMS, you get true visibility into what's actually happening - and what the real delta is. The package remains open source (https://lnkd.in/ebEjSqAc), but if you need help implementing it, we're here. At falcon health, we're already helping many MAPDs gain full visibility into their claim journey and HCC performance (feat. Prince Baawuah, DrPH, MPH, CSM®) Interested in learning more? Let's connect!

42

5 Comments

I'm building an Electron app with AI. The AI writes all of the code. One pattern I keep catching: it imports Node.js modules directly in the renderer process. Or pulls business logic into the UI instead of routing through IPC. The code compiles and passes unit tests. It just quietly breaks the process isolation that keeps the UI sandboxed. I got tired of catching these in code review. I remembered a conversation with a former colleague, Siddharth Goel, about ArchUnit for Java, which lets you write architecture rules as tests. I checked if a TypeScript port existed. It does (archunit on npm). Things like: "The UI layer can't import the database driver." "SQL queries must use placeholders, never string concatenation." I have twenty-five of these rules now, all running at pre-commit. You can put architecture guidelines into the AI's prompt, and it follows them most of the time. Most of the time isn't enough for security boundaries. But the test catches it every time. And the rules double as architecture documentation that never goes stale. Curious how others handle this. Automated rules, manual review, or something else that worked? #AI #SoftwareArchitecture #CodeQuality

44

16 Comments

Modernization isn’t demolition. It’s integration. Legacy systems contain institutional knowledge, not just outdated code. The agencies that succeed are the ones blending old architecture with new thinking.

1

Openclaw joining OpenAI feels like the closest signal yet that the “one-person unicorn” era might not be fiction. If this model scales, headcount stops signaling capability, leverage shifts to agentic systems and architecture, and founders win on system design—not org size. We’re moving from “build a team” to “build a machine.” #AI #Startups #Founders #AgenticAI #FutureOfWork

2

3 Comments