Importance of Clear Code in LLM Development

No, you won't be vibe coding your way to production. Not if you prioritise quality, safety, security, and long-term maintainability at scale. Recently coined by former OpenAI co-founder Andrej Karpathy, "vibe coding" describes an AI-coding approach where developers focus on iterative prompt refinement to generate desired output, with minimal concern for the LLM-generated code implementation. At Canva, our assessment — based on extensive and ongoing evaluation of AI coding assistants — is that these tools must be carefully supervised by skilled engineers, particularly for production tasks. Engineers need to guide, assess, correct, and ultimately own the output as if they had written every line themselves. Our experimentation consistently reveals errors in tool-generated code ranging from superficial (style inconsistencies) to dangerous (incorrect, insecure, or non-performant code). Our engineering culture is built on code ownership and peer review. Rather than challenging these principles, our adoption of AI coding assistants has reinforced their importance. We've implemented a strict "human in the loop" approach that maintains rigorous peer review and meaningful code ownership of AI-generated code. Vibe coding presents significant risks for production engineering: - Short-term: Introduction of defects and security vulnerabilities - Medium to long-term: Compromised maintainability, increased technical debt, and reduced system understandability From a cultural perspective, vibe coding directly undermines peer review processes. Generating vast amounts of code from single prompts effectively DoS attacks reviewers, overwhelming their capacity for meaningful assessment. Currently we see one narrow use case where vibe coding is exciting: spikes, proofs of concept, and prototypes. These are always throwaway code. LLM-assisted generation offers enormous value in rapidly testing and validating ideas with implementations we will ultimately discard. With rapidly expanding LLM capabilities and context windows, we continuously reassess our trust in LLM output. However, we maintain that skilled engineers play a critical role in guiding, assessing, and owning tool output as an immutable principle of sound software engineering.

Clean code isn't just about readability —it's about creating maintainable, scalable solutions that stand the test of time. When we prioritize readability, simplicity, and thoughtful architecture, we're not just making our lives easier; we're creating value for our teams and organizations. A few principles that have made the most significant difference in my work over years: • Meaningful naming that reveals intent • Functions that do one thing exceptionally well • Tests that serve as documentation and safety nets • Consistent formatting that reduces cognitive load The greatest insight I've gained is that clean code is fundamentally an act of communication—with future developers, our teammates, and even our future selves. The time invested upfront pays dividends during maintenance, debugging, and onboarding. What clean code practices have transformed your development experience? I'd love to hear about the principles that guide your work. Image Credit - Keivan Damirchi

How to Use AI to Build Things (Even If You’re Not Technical) — #4 LLMs can write working code, but it becomes far more useful when we reshape it to match how we think as #clinicians. That means refactoring not just for clarity, but to align with our clinical mental models. Take a creatinine clearance calculation. Instead of leaving it as one big block, break it into steps that reflect how we think: - calc_ideal_body_weight() and calc_adjusted_body_weight() - select_weight_to_use() - choose_crcl_formula(sex) - calculate_crcl() — combines all steps into one reusable abstraction Now the code mirrors our clinical workflow making it easier to understand, validate, and explain. There's also a technical bonus too :) - Reusability: use functions across tools - Readability: clearer for you and collaborators who are less technical - Composability: build complex workflows from simple parts If the LLM gives you raw code, ask it to refactor into functions. Then inject your domain knowledge to structure it in a way that makes sense to you. #HealthcareOnLinkedIn #VibeCoding #AI

Most AI code isn’t broken. It’s just broken enough to break you. LLMs sound confident. They move fast. Their code looks perfect… until it runs. Then come the silent bugs and missed edge cases. Here are 8 principles from Simon Willison that stop the bugs before they stop your team: 🔸 LLMs are junior developers, not autonomous agents ↳ They need structure, supervision, and review. You wouldn’t ship a junior’s code without checking it. Don’t ship an LLM’s code without testing it thoroughly. 🔸 Context quality determines output quality ↳ The difference between usable and unusable code often comes down to context. Include requirements, constraints, edge cases, and error handling needs. Specificity here prevents hours of debugging later. 🔸 Knowledge cutoffs matter ↳ GPT-4 was trained up to October 2023. Claude 3.5 up to April 2024. LLMs won’t know the latest changes to libraries or APIs so verify against current docs every time. 🔸 Use iterative refinement ↳ Start with a broad prompt: “What are my implementation options?” Then narrow it: “Implement option 2 using these parameters.” Then polish: “Add robust error handling and tests.” This mirrors how senior developers already think. 🔸 Test every generated line ↳ LLMs are confident, even when wrong. They excel at writing syntactically correct code with subtle logical flaws. Assume nothing works until it's tested. 🔸 Leverage safe execution environments ↳ Tools like Claude Artifacts and ChatGPT Code Interpreter let you run code in a sandbox. Validate before you deploy. This step prevents production incidents. 🔸 Embrace ‘vibe-coding’ for discovery ↳ Use vibe-coding to test ideas, experiment, and learn system boundaries. That experimentation leads to sharper production use. 🔸 LLMs amplify existing expertise ↳ They make experienced developers faster. They don’t replace core understanding. If you’re not leveling up alongside your tools, you’re falling behind. The engineers getting the most out of AI aren’t asking it to code. They’re treating it like a teammate with limits. What’s your most effective LLM workflow? ♻️ Repost to help your team use AI more strategically ➕ Follow me, Sairam, for practical AI engineering insights

Recently, Andre Karpathy introduced "vibe coding", a style of programming with AI assistance. While the idea of a relaxed chat with an LLM yielding a working system sounds seductive, I believe it fundamentally misses the point of what programming is truly about. Many mistakenly believe that writing code is the hard part of software development. In reality, the true challenge lies in breaking down complex problems into the precise, deterministic instructions that computers require. Programming languages aren't just arbitrary tools; they've evolved to help us structure our thinking, decompose problems, and communicate our understanding with clarity and precision to both other humans and the computer. The rise of AI in programming highlights three critical problems we need to address: • How do we specify what we want with precise detail? Natural language, as seen in legal documents, often lacks the clarity and precision needed. • How do we confirm that we got what we wanted? This makes automated testing even more crucial for AI-generated code. • How do we retain our ability to make measurable progress in small, controlled steps? AI's tendency to regenerate entire codebases from scratch after small changes profoundly complicates our traditional methods of incremental development, version control, and safe system evolution. Ignoring the importance of being able to revisit, correct, and enhance code is a mistake we've seen before with other attempts to raise the level of abstraction in programming. Vibe coding, by seemingly allowing us to "give into the vibes and forget that the code even exists," doesn't address these foundational challenges. Software engineering isn't dying, it's evolving. But for any next step in programming to be successful, it must tackle these fundamental issues head-on. Watch my video on vibe coding now on the Modern Software Engineering channel.