The Importance of Software Liability

The mantra, "Your customers don’t care about your code," is often repeated, especially on platforms like LinkedIn. While there’s some truth in the idea that customers are generally uninterested in the technical details behind software, this oversimplification misses a critical point: ignoring the quality of the code has long-term consequences. At first glance, the mantra might seem harmless. After all, if the product works, what’s the problem? But the danger lies in the assumption that "just working" is enough for the long haul. Customers might not care about the underlying code when the software meets their needs in the short term. However, over time, software that lacks proper engineering will show its cracks. It won’t scale as the user base grows, it will become unstable, and adding new features or making changes will become exponentially harder. What was once a functional product can devolve into a fragile, unmanageable system that undermines the business it’s meant to support. The repeated mantra justifies cutting corners, favoring quick solutions over long-term quality. This neglects the importance of code quality in building robust, maintainable, and scalable software. Without it, risks increase, maintenance becomes costly, and technical debt accumulates, turning quick fixes into long-term liabilities. Imagine this in the context of a physical product. No customer would accept a product that seems to function but is poorly assembled, non-compliant with safety standards, and difficult to maintain. Initially, it may work, but over time, its flaws will surface - it could become unsafe, unreliable, and hard to repair. This is what happens when businesses cut corners in software development. They say, "If it works, it works," but this is a shortsighted view that leads to long-term issues. Neglecting code quality puts both software stability and the business model at risk. A product that works today can lead to frustrations tomorrow, causing customer churn and reputational damage. As systems age, maintaining them becomes costlier, reducing agility and increasing vulnerability to security issues. The "your customers don’t care" argument overlooks the fact that customers do care - about reliability, security, and performance. They want updates that don't break things and assurance that their data is protected. These elements are all rooted in high-quality code. By neglecting code quality, businesses risk not only technical failure but also losing customer trust. A well-engineered product continues to serve its purpose and evolve, while a poorly built one may "seem to work" - until it doesn't. Ultimately, great software isn't just about meeting immediate needs, but ensuring future stability and security. "It seems to work" is a short-term fix, while investing in high-quality code ensures long-term reliability, adaptability, and value.

Yesterday, I had an insightful conversation with a seasoned software product leader, and one phrase stuck with me: Code is liability. At first, it sounds counterintuitive. We often think of code as an asset—something that brings value to a company. But the reality is that every line of code written comes with inherent costs and risks. Here’s why: 1. Maintenance Burden – Code isn’t a one-time investment. Every feature added increases the surface area for bugs, security vulnerabilities, and technical debt. The more code you have, the more effort it takes to maintain. 2. Complexity & Fragility – The more code you write, the harder it becomes to make changes without breaking something else. What starts as a simple solution can quickly turn into a tangled mess requiring extensive rework. 3. Scalability Risks – As software evolves, poorly designed or unnecessary code can bottleneck performance. What works today may slow you down tomorrow, requiring costly refactoring or complete rewrites. 4. Opportunity Cost – Time spent managing and debugging bloated codebases is time not spent on innovation. The best software companies minimize unnecessary code and focus on delivering value efficiently. 5. Security Vulnerabilities – Every additional line of code is a potential attack vector. The larger the codebase, the more opportunities for exploits. This conversation reinforced something I’ve seen firsthand: The best engineers and product leaders aren’t the ones who write the most code—they’re the ones who write the least necessary code. In a world where we celebrate shipping new features, we often overlook the cost of what we’ve built. Sometimes, the best decision isn’t to add more—it’s to simplify, refactor, or even delete.

💥 𝗬𝗼𝘂𝗿 𝗕𝘂𝘀𝗶𝗻𝗲𝘀𝘀 𝗥𝘂𝗻𝘀 𝗼𝗻 𝗖𝗼𝗱𝗲—𝗦𝗼 𝗪𝗵𝘆 𝗔𝗿𝗲 𝗬𝗼𝘂 𝗚𝗮𝗺𝗯𝗹𝗶𝗻𝗴 𝗪𝗶𝘁𝗵 𝗜𝘁? In 2024, UK businesses lost an estimated £3.6 million each due to IT failures. Yet, most companies still treat software maintenance as an afterthought—waiting for a breakdown before scrambling to fix it. Let’s be clear: downtime is 𝗡𝗢𝗧 a tech issue. It’s a revenue, reputation, and survival issue. When systems crash: 🚨 Revenue stops—Every minute costs an average of £4,300 in lost sales. 🚨 Customers leave—91% of UK consumers won’t return after a bad digital experience. 🚨 Reputation takes a hit—Frustrated users don’t wait; they switch. So why do so many businesses still react to failures instead of preventing them? 𝙏𝙝𝙚 𝙎𝙞𝙡𝙚𝙣𝙩 𝙆𝙞𝙡𝙡𝙚𝙧 𝙞𝙣 𝙔𝙤𝙪𝙧 𝙏𝙚𝙘𝙝 𝙎𝙩𝙖𝙘𝙠 Warning signs that your business is heading for a tech disaster: ⚠️ Frequent system crashes or slow performance—frustrating employees and customers alike. ⚠️ Delayed software updates & security patches—opening the door to cyberattacks. ⚠️ Unexpected outages during peak periods—costing thousands in lost sales. If any of these sound familiar, your business isn’t running software—it’s running on borrowed time. 𝙏𝙝𝙚 𝙎𝙢𝙖𝙧𝙩 𝙁𝙞𝙭: 𝙋𝙧𝙤𝙖𝙘𝙩𝙞𝙫𝙚 𝙎𝙤𝙛𝙩𝙬𝙖𝙧𝙚 𝙎𝙩𝙖𝙗𝙞𝙡𝙞𝙩𝙮 Preventing downtime isn’t about waiting for the next crisis. It’s about engineering resilience into your systems. 🔹 Emergency Bug Fixing & System Rollbacks – Rapid-response fixes to restore operations fast. 🔹 Automated Security Patching – Shield your business from compliance fines and cyber risks. 🔹 Scalability Planning – Ensure your systems can handle peak demand without breaking. 🔹 AI-Powered Monitoring – Catch small issues before they turn into major failures. At Full Metal Software, we specialise in Maintenance Rescue—helping UK businesses avoid IT catastrophes before they happen. 𝙇𝙚𝙩’𝙨 𝙏𝙖𝙡𝙠: 𝙄𝙨 𝙔𝙤𝙪𝙧 𝘽𝙪𝙨𝙞𝙣𝙚𝙨𝙨 𝘽𝙪𝙞𝙡𝙩 𝙛𝙤𝙧 𝙍𝙚𝙨𝙞𝙡𝙞𝙚𝙣𝙘𝙚? ❓ When was the last time your software was audited for risks? ❓ What’s your biggest challenge in keeping systems running 24/7? Let’s discuss how UK businesses can move from reacting to IT failures to building bulletproof systems that just work. 📩 Drop a comment or DM me if you want a free software health check—before the next outage costs you thousands. . . . . . #SoftwareReliability #BusinessContinuity #ITLeadership

Code can automate decisions, but not responsibility. This distinction will determine which AI companies survive the next decade. As AI agents become more autonomous, I've noticed an interesting pattern: the more advanced the system, the more crucial the accountability framework becomes. Contract law wasn't designed for robots. It emerged from centuries of human commercial relationships, centered on a simple principle: when things go wrong, someone specific must be accountable. Even the most sophisticated agentic AI exists within this reality. While algorithms make decisions, liability still flows to identifiable entities—companies, executives, developers, operators. This isn't a limitation, it's a feature. I've watched enterprise AI deployments stall not because of technical issues, but because no one could answer the simple question: "Who's responsible when this fails?" The companies winning major contracts aren't those promising to remove humans entirely. They're the ones who've thoughtfully designed where and how humans remain accountable within their AI systems. Some founders view liability as friction to be engineered away. The successful ones recognize it as the foundation of customer trust. Consider: Financial institutions won't adopt AI that can't trace decisions to accountable parties. Healthcare providers require clear liability chains. Government contracts demand specific responsible entities. Where technology meets commerce, accountability isn't negotiable. This creates a counter-intuitive advantage for founders building AI companies: clarity about responsibility accelerates adoption. Well-defined liability frameworks reduce perceived risk. Transparent accountability protocols build institutional trust. Responsibility frameworks aren't limitations on AI—they're the foundations that make widespread business adoption possible. The capital-labor equation will continue shifting with AI advancement. But indemnity, liability, and accountability will remain firmly anchored to humans and the organizations they create. Business is fundamentally about creating accountability structures that enable valuable risk-taking. The most successful AI founders aren't those trying to eliminate human responsibility—they're the ones designing optimal interfaces between algorithmic capability and human accountability. #startups #founders #growth #ai

I once worked with an engineer who came to me in frustration because every time he connected a very expensive computer chip module to a larger module, it would short-circuit. "The documentation is wrong," he told me. "Why did you let it go out that way?" I went into my records and found the information about connecting that module. "Ahem, you were the engineer who approved the content for that section," I informed him, to which he replied, "Well, I didn't know what it was for!" But the damage had been done. All clients had received paper instructions with their products, and anyone performing the same procedure would also short-circuit their module. And it was the company's fault.   Inaccurate, outdated, or incomplete documentation can have significant consequences. Here are some of the top contenders, some of which cost organisations millions of dollars and even saw the closure of the company.   1. Increased support costs Incorrect documentation can lead to more support inquiries, particularly when the information on the customer support site reflects the same mistakes as the documentation. Companies have calculated that having useful - clear, complete, concise, and correct - content can reduce the cost of answering support queries by up to 50%. 2. Decreased productivity Staff who rely on documentation, such as Standard Operating Procedures, to perform particular tasks cannot only engage in activities that waste time, but also results in a waste of materials, such as production line errors. 3. Inaccurate Implementation I've seen two weeks of a software team's development time wasted because they based their work on an incorrect specification, incurring a significant loss for the corporation and a delay that incurred penalties for the late delivery. 4. Compliance Risks In regulated industries, inaccurate documentation can lead to compliance violations, resulting in legal consequences. One client calculated that inaccurate documentation could have cost the company hundreds of thousands of dollars every quarter because of potential lawsuits brought against the customers of their product by disgruntled users. 5. Reputational Damage Trust in a brand's documentation reflects on user experience, reliability, and general trustworthiness. Inaccurate documentation, particularly content that prevents users from setting up a product, breaking the product, or impeding its use, can result in customer complaints, "no fault found" returns, and loss of customer loyalty. Customers won't read your documentation the way they would read a novel, but when they do need it, they expect you to have done right by them, and done it right.

AI liability is about to get real. The lawsuit against OpenAI over a teenager’s ChatGPT-assisted death isn’t just about one tragic case. It could redefine how enterprises must treat AI. If courts accept these claims, AI will no longer be “just software.” It will be judged like a dangerous product - with strict liability, duty to warn, and negligence standards applied. For enterprises, the ripple effects are enormous: 1. Product liability exposure - Deploying AI could carry the same legal risks as selling a defective car or medical device. “Use at your own risk” disclaimers won’t be enough. 2. Duty to warn - Expect mandatory disclaimers, onboarding risk screens, and context-specific safety alerts when AI is used in HR, finance, or healthcare. 3. Governance as legal defense - Companies will need documented AI safety frameworks (NIST/ISO-style) to prove they took “reasonable care.” 4. Unlicensed practice risk - If courts rule AI engaged in psychology, similar arguments could apply to AI in law, medicine, or finance. Human oversight may become legally required. 5. Insurance shake-up - AI-specific liability coverage will become a must-have, not an afterthought. This could be the moment where AI moves from “experimental software” to regulated, high-liability product. Enterprise leaders should start planning now: • Demand transparency from vendors on safety testing and controls. • Implement “safety by design” in internal AI programs. • Review insurance, compliance, and risk frameworks before lawsuits force the issue. The question is no longer if AI liability will hit enterprises, it’s when, and how prepared you’ll be.

Behind the Blue Screen: How the CrowdStrike Glitch Exposed Global Vulnerabilities Have you ever considered how a single software update could paralyze global operations? This alarming reality unfolded on July 19, when a routine update from CrowdStrike, a leading cybersecurity firm, caused widespread disruption. For me, the impact was intensely personal as my computer crashed the night before a crucial lecture for LLM students. Despite multiple reboot attempts, my anxiety grew as my case studies remained inaccessible. We were facing the infamous ‘Blue Screen of Death’—a critical system error in Windows that sounds like the punchline of a bad tech joke, but the reality was far from humorous. This routine software update had escalated into a worldwide disruption. Immediate Economic Impact The CrowdStrike BSOD incident had far-reaching consequences. Airlines experienced delays and cancellations, grounding flights and stranding passengers. Major banks reported halted transactions, leading to customer frustration and financial losses. This incident starkly illustrated how a single software patch could disrupt global operations. According to Gartner, the average cost of IT downtime is $5,600 per minute, equating to over $300,000 per hour. By 2025, 60% of organizations are expected to suffer major service failures due to mismanagement of cyber risks. Beyond the economic repercussions, this incident also highlighted significant legal challenges. Legal Implications In addition to economic turmoil, the incident posed significant legal challenges. CrowdStrike may face lawsuits from businesses claiming damages. Grounded flights could result in breach of contract claims and passenger compensation demands. This raises critical questions about the liability of software providers for unintended update consequences. Such incidents may prompt regulators to introduce stricter requirements for software update testing and validation. Lessons for Businesses This incident is a stark reminder for businesses to reassess their reliance on third-party software and improve their preparedness for disruptions. Regularly reviewing risk management strategies and developing robust contingency plans is essential. Ensuring vendor agreements outline responsibilities, liabilities, and mitigation processes for update-related issues can help minimize the impact. These steps are crucial for maintaining operational continuity and reducing potential damages. The CrowdStrike BSOD incident underscores the urgent need for businesses to be prepared for digital disruptions. Strengthening legal frameworks and enhancing risk management are vital. This incident serves as a wake-up call: businesses must fortify their defenses against the unexpected. Personally, this experience reminded me of the importance of having reliable backups and a robust contingency plan. Is your organization prepared for the next disruption? #TechDisruption #RiskManagement #Cybersecurity #BusinessContinuity

𝗢𝗽𝗲𝗻 𝗦𝗼𝘂𝗿𝗰𝗲 & 𝗟𝗶𝗮𝗯𝗶𝗹𝗶𝘁𝘆: 𝗧𝗵𝗲 𝗨𝗻𝗰𝗼𝗺𝗳𝗼𝗿𝘁𝗮𝗯𝗹𝗲 𝗤𝘂𝗲𝘀𝘁𝗶𝗼𝗻 𝗶𝗻 𝗔𝘂𝘁𝗼𝗺𝗼𝘁𝗶𝘃𝗲 (𝘗𝘦𝘳𝘴𝘰𝘯𝘢𝘭 𝘷𝘪𝘦𝘸; 𝘰𝘱𝘪𝘯𝘪𝘰𝘯𝘴 𝘢𝘳𝘦 𝘮𝘺 𝘰𝘸𝘯) Open-source software (OSS) already represents 𝘂𝗽 𝘁𝗼 𝟳𝟬% 𝗼𝗳 𝘁𝗵𝗲 𝗰𝗼𝗱𝗲 𝗶𝗻 𝗺𝗼𝗱𝗲𝗿𝗻 𝘃𝗲𝗵𝗶𝗰𝗹𝗲𝘀. The trend is irreversible - driven by the need for faster innovation, transparency, and reduced vendor lock-in. But as OSS moves from the toolchain to the in-vehicle stack, it raises an uncomfortable question: When a component with no warranty contributes to a failure, who is liable? This tension will define the next chapter of the Software-Defined Vehicle. 𝟭. 𝗧𝗿𝗮𝗻𝘀𝗽𝗮𝗿𝗲𝗻𝗰𝘆 𝗶𝘀 𝘁𝗵𝗲 𝗡𝗲𝘄 𝗦𝘁𝗮𝗻𝗱𝗮𝗿𝗱 Safety doesn’t come from secrecy - it comes from process, evidence, and traceability. When code is open, quality can be verified, security audited, and interoperability improved by design. Initiatives like Automotive Grade Linux (AGL) and the Eclipse SDV Working Group already prove that openness and safety are not mutually exclusive. 𝟮. 𝗧𝗵𝗲 𝗜𝗻𝗲𝘀𝗰𝗮𝗽𝗮𝗯𝗹𝗲 𝗟𝗶𝗮𝗯𝗶𝗹𝗶𝘁𝘆 𝗤𝘂𝗲𝘀𝘁𝗶𝗼𝗻 Most OSS licenses explicitly disclaim warranties - a stark contrast to a regulated industry where accountability is non-negotiable. The real challenge isn’t if we should use OSS, but how we build a framework of responsibility around it. 𝗪𝗵𝗼 𝗶𝘀 𝗮𝗰𝗰𝗼𝘂𝗻𝘁𝗮𝗯𝗹𝗲? The OEM? The Tier-1 integrator? The community? 𝟯. 𝗧𝘄𝗼 𝗠𝗼𝗱𝗲𝗹𝘀 𝗪𝗶𝗹𝗹 𝗘𝗺𝗲𝗿𝗴𝗲 We’re heading toward a hybrid future: 𝗢𝗘𝗠-𝗠𝗮𝗶𝗻𝘁𝗮𝗶𝗻𝗲𝗱 𝗢𝗦𝗦: Automakers will own, qualify, and maintain critical parts of the open-source stack internally. 𝗖𝗼𝗺𝗺𝗲𝗿𝗰𝗶𝗮𝗹 𝗗𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗶𝗼𝗻𝘀: Partners - much like Red Hat for enterprise Linux—will provide validated OSS stacks with long-term support, security patches, and, crucially, contractual liability. 𝟰. 𝗜𝗻𝗶𝘁𝗶𝗮𝘁𝗶𝘃𝗲𝘀 𝗣𝗮𝘃𝗶𝗻𝗴 𝘁𝗵𝗲 𝗪𝗮𝘆 The Eclipse SDV ecosystem is already shaping this accountable future with projects like:  • 𝗘𝗰𝗹𝗶𝗽𝘀𝗲 𝗦-𝗖𝗼𝗿𝗲 – a reference architecture for certifiable, modular vehicle software.  • 𝗘𝗰𝗹𝗶𝗽𝘀𝗲 𝗢𝗽𝗲𝗻𝗦𝗢𝗩𝗗 – an open standard for vehicle diagnostics and off-board interaction.  • 𝗘𝗰𝗹𝗶𝗽𝘀𝗲 𝗢𝗽𝗲𝗻𝗕𝗦𝗪 – open implementations for essential Base Software modules, defining the next frontier of in-vehicle OSS. 𝗧𝗵𝗲 𝗙𝘂𝘁𝘂𝗿𝗲 𝗶𝘀 𝗢𝗽𝗲𝗻 - 𝗕𝘂𝘁 𝗥𝗲𝘀𝗽𝗼𝗻𝘀𝗶𝗯𝗹𝗲 The shift to open source is unstoppable. The challenge now is to make it 𝘀𝗮𝗳𝗲, 𝗺𝗮𝗶𝗻𝘁𝗮𝗶𝗻𝗮𝗯𝗹𝗲, 𝗮𝗻𝗱 𝗹𝗲𝗴𝗮𝗹𝗹𝘆 𝘀𝘂𝘀𝘁𝗮𝗶𝗻𝗮𝗯𝗹𝗲. 𝗧𝗵𝗲 𝗳𝘂𝘁𝘂𝗿𝗲 𝗼𝗳 𝗮𝘂𝘁𝗼𝗺𝗼𝘁𝗶𝘃𝗲 𝘀𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝘄𝗶𝗹𝗹 𝗯𝗲 𝗼𝗽𝗲𝗻 -  𝘄𝗶𝘁𝗵 𝗹𝗶𝗮𝗯𝗶𝗹𝗶𝘁𝘆 𝗱𝗲𝘀𝗶𝗴𝗻𝗲𝗱 𝗶𝗻, 𝗻𝗼𝘁 𝗯𝗼𝗹𝘁𝗲𝗱 𝗼𝗻. What’s your view? How is your organization preparing for this shift? #Automotive #SoftwareDefinedVehicle #OpenSource #AutomotiveIndustry #Liability #TechLeadership #EmbeddedSystems #EclipseSDV

Microsoft premium service purchasers were able to handle the recent MS email hack more easily than those who purchased lower tier services. Senator Wyden responded saying, "charging people for premium features necessary to not get hacked is like selling a car and then charging extra for seatbelts and airbags.” While the point is worth reflecting on, it's not an ideal analogy. Seatbelts are indeed mandatory, however the auto market offers safer options at higher prices (you can call them both cars, but if you've ridden in a Volvo AND a Yugo...). No matter how safe or unsafe a car is, when there is an accident, an automaker can be held accountable for manufacturing defects that contribute to the accident. Unlike auto manufacturers, it is very difficult to hold software makers accountable for product defects. Liability is normally disclaimed in license agreements and the negligence threshold for software developers is amorphous. Balancing the benefits of innovation and demands for regulation will be one of the hardest National Cybersecurity Strategy objectives to achieve. It is critical to the U.S. economy and national security. Software developers must be included as regulations are considered if the U.S. is to find the appropriate balance.

In my early days at ProofHQ, our system went down every time I got on a plane. Every time I touched down, I’d check my phone—and boom, another outage. Back then, we didn’t have in-flight Wi-Fi, so when I was on a transatlantic flight I was totally incommunicado. It became a bit of a running joke: “The system runs on Ant’s laptop—when he shuts it down for a flight, the whole thing crashes.” Funny joke. But in reality, it was a huge problem. In software, the product simply has to work. It’s what people are paying for. So when your system is down and your software isn’t working for your clients—you have a major, major issue. Downtime affected our team’s morale, but it also hurt our trust and credibility with our customers. I often spent those first few hours in my hotel room calling clients to try to smooth things over. Eventually, I realized this problem wasn’t going away. We needed to get serious about the service we were providing to our customers. We had to improve our uptime. So we took a step back and rebuilt our architecture. We introduced a simple principle: run three of everything—one for us, one for the client, one as a backup. That decision changed everything. It gave us the buffer we needed. Reliability improved. The firefighting stopped. We built confidence with our clients—and with our team. We’ve continued to run a similar protocol at Ziflow to ensure maximum reliability for our clients. Here’s the truth: all software will go down at some point. But that should be a rarity—not the norm. When you’re running a start-up, everything can seem urgent. Believe me, I know firsthand how hard those first years can be. But the number 1, absolutely top priority has to be: does your product work, consistently?