Tips for Balancing Speed and Quality in AI Coding

Most developers treat AI coding agents like magical refactoring engines, but few have a system, and that's wrong. Without structure, coding with tools like Cursor, Windsurf, and Claude Code often leads to files rearranged beyond recognition, subtle bugs, and endless debugging. In my new post, I share the frameworks and tactics I developed to move from chaotic vibe coding sessions to consistently building better, faster, and more securely with AI. Three key shifts I cover: -> Planning like a PM – starting every project with a PRD and modular project-docs folder radically improves AI output quality -> Choosing the right models – using reasoning-heavy models like Claude 3.7 Sonnet or o3 for planning, and faster models like Gemini 2.5 Pro for focused implementation -> Breaking work into atomic components – isolating tasks improves quality, speeds up debugging, and minimizes context drift Plus, I share under-the-radar tactics like: (1) Using .cursor/rules to programmatically guide your agent’s behavior (2) Quickly spinning up an MCP server for any Mintlify-powered API (3) Building a security-first mindset into your AI-assisted workflows This is the first post in my new AI Coding Series. Future posts will dive deeper into building secure apps with AI IDEs like Cursor and Windsurf, advanced rules engineering, and real-world examples from my projects. Post + NotebookLM-powered podcast https://lnkd.in/gTydCV9b

I've been using AI coding tools for a while now & it feels like every 3 months the paradigm shifts. Anyone remember putting "You are an elite software engineer..." at the beginning of your prompts or manually providing context? The latest paradigm is Agent Driven Development & here are some tips that have helped me get good at taming LLMs to generate high quality code. 1. Clear & focused prompting ❌ "Add some animations to make the UI super sleek" ✅ "Add smooth fade-in & fade out animations to the modal dialog using the motion library" Regardless of what you ask, the LLM will try to be helpful. The less it has to infer, the better your result will be. 2. Keep it simple stupid ❌ Add a new page to manage user settings, also replace the footer menu from the bottom of the page to the sidebar, right now endless scrolling is making it unreachable & also ensure the mobile view works, right now there is weird overlap ✅ Add a new page to manage user settings, ensure only editable settings can be changed. Trying to have the LLM do too many things at once is a recipe for bad code generation. One-shotting multiple tasks has a higher chance of introducing bad code. 3. Don't argue ❌ No, that's not what I wanted, I need it to use the std library, not this random package, this is the 4th time you've failed me! ✅ Instead of using package xyz, can you recreate the functionality using the standard library When the LLM fails to provide high quality code, the problem is most likely the prompt. If the initial prompt is not good, follow on prompts will just make a bigger mess. I will usually allow one follow up to try to get back on track & if it's still off base, I will undo all the changes & start over. It may seem counterintuitive, but it will save you a ton of time overall. 4. Embrace agentic coding AI coding assistants have a ton of access to different tools, can do a ton of reasoning on their own, & don't require nearly as much hand holding. You may feel like a babysitter instead of a programmer. Your role as a dev becomes much more fun when you can focus on the bigger picture and let the AI take the reigns writing the code. 5. Verify With this new ADD paradigm, a single prompt may result in many files being edited. Verify that the code generated is what you actually want. Many AI tools will now auto run tests to ensure that the code they generated is good. 6. Send options, thx I had a boss that would always ask for multiple options & often email saying "send options, thx". With agentic coding, it's easy to ask for multiple implementations of the same feature. Whether it's UI or data models asking for a 2nd or 10th opinion can spark new ideas on how to tackle the task at hand & a opportunity to learn. 7. Have fun I love coding, been doing it since I was 10. I've done OOP & functional programming, SQL & NoSQL, PHP, Go, Rust & I've never had more fun or been more creative than coding with AI. Coding is evolving, have fun & let's ship some crazy stuff!

𝗧𝗟;𝗗𝗥: AWS Distinguished Engineer Joe Magerramov's team achieved 10x coding throughput using AI agents—but success required completely rethinking their testing, deployment, and coordination practices. Bolting AI onto existing workflows will create crashes, not breakthroughs. Joe M. is an AWS Distinguished Engineer who has architected some of Amazon's most critical infrastructure, including foundational work on VPCs and AWS Lambda. His latest insights on agentic coding (https://lnkd.in/euTmhggp) come from real production experience building within Amazon Bedrock. 𝗧𝗵𝗲 𝗧𝗵𝗿𝗼𝘂𝗴𝗵𝗽𝘂𝘁 𝗣𝗮𝗿𝗮𝗱𝗼𝘅 Joe's team now ships code at 10x typical high-velocity teams—measured, not estimated. About 80% of committed code is AI-generated, but every line is human-reviewed. This isn't "vibe coding." It's disciplined collaboration between engineers and AI agents. But here's the catch: At 10x velocity, the math changes completely. A bug that occurs once a year at normal speed becomes a weekly occurrence. Their team experienced this firsthand. 𝗧𝗵𝗲 𝗜𝗻𝗳𝗿𝗮𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 𝗚𝗮𝗽 Success required three fundamental shifts:  • 𝗧𝗲𝘀𝘁𝗶𝗻𝗴 𝗿𝗲𝘃𝗼𝗹𝘂𝘁𝗶𝗼𝗻 - They built high-fidelity fakes of all external dependencies, enabling full-system testing at build time. Previously too expensive; now practical with AI assistance.  • 𝗖𝗜𝗖𝗗 𝗿𝗲𝗶𝗺𝗮𝗴𝗶𝗻𝗲𝗱 - Traditional pipelines taking hours to build and days to deploy create "Yellow Flag" scenarios where dozens of commits pile up waiting. At scale, feedback loops must compress from days to minutes.  • 𝗖𝗼𝗺𝗺𝘂𝗻𝗶𝗰𝗮𝘁𝗶𝗼𝗻 𝗱𝗲𝗻𝘀𝗶𝘁𝘆 - At 10x throughput, you're making 10x more architectural decisions. Asynchronous coordination becomes the bottleneck. Their solution: co-location for real-time alignment. 𝗔𝗰𝘁𝗶𝗼𝗻 𝗳𝗼𝗿 𝗖𝗧𝗢𝘀 Don't just give your teams AI coding tools. Ask:  • Can your CI/CD handle 10x commit volume?  • Will your testing catch 10x more bugs before production?  • Can your team coordinate 10x faster? The winners won't be those who adopt AI first—they'll be those who rebuild their development infrastructure to sustain AI-driven velocity.

Code much faster with AI, but at what cost… Ignore quality and maintainability issues? Or spend hours reviewing code we haven’t written? A Theodo team explored ingenious ways to break that trade-off. Antoine de Chassey , Hugo Borsoni, Thibault Lemery and Margaux Theillier led a 6-step kaizen on accelerating AI-code reviews without sacrificing quality. Based on extensive experience, they’ve identified that AI is much more reliable when it is building components by copying an existing good example. So they tagged good examples they called blueprints. And then asked the AI to make it explicit, on the code generated, whether it was able to copy a blueprint or not. This allowed them to focus their code reviews on all the places where the AI wasn’t able to copy a blueprint, places that are much more prone to quality issues. A very ingenious way to review all the code, ensuring maximum quality, while focusing attention on the less reliable places. Well done for that great example of Lean Tech in action at Theodo!

I've spent 9 months figuring out what actually works with AI coding tools—especially on messy, real-world codebases. The breakthrough? Stop letting AI write code until you've reviewed a written plan. Here's the flow that I keep seeing when researching, and Boris has done a great job in collecting the whole thing in his blog: 1. Research Phase: Don't accept verbal summaries. Force deep reads into persistent files. "Read auth/middleware deeply. Write findings in research.md with intricacies." Written artifacts = review surfaces. Catches misunderstandings before they become broken implementations. 2. Planning Phase: Request detailed plans in plan.md—with code snippets, file paths, trade-offs. Not the built-in plan mode (very important!). Custom markdown files you control. 3. Annotation Cycle (the critical part): Review the plan in your editor. Add inline notes directly: - "This breaks OAuth flow" - "Use existing UserService instead" - "Security: validate input here" Send annotated plan back. Repeat 1-6 times until it's right. This is where the main thinking happens! 4. Then—and only then—implement This prevents the most expensive failure: code that works in isolation but breaks everything around it. Pro tip: For standard features, provide reference implementations from open source. Claude with a concrete example >>> Claude designing from scratch. The workflow feels slower at first. But catching architectural mistakes in a 50-line plan.md beats debugging a 500-line implementation that went wrong from line 1. This process is now called RPI (Reserch, Plan, Implement) - have you tried this in your workflows yet? https://lnkd.in/dMP7dCgc

AI makes developers faster. But what happens when that value comes at the cost of actually understanding what you're building? When researchers at Anthropic tested 52 professional developers learning an unfamiliar Python library, the AI-assisted group scored 17% lower on conceptual understanding, code reading, and debugging — across all experience levels. There was also no significant difference in task completion time. 🔴 The biggest skill gap was in debugging. The control group hit a median of 3 errors during the task versus just 1 for the AI group. Working through those errors is what made the concepts stick. 🔴 Not all AI usage was equal. Developers who asked conceptual questions scored 65-86% on the skills quiz. Those who just delegated code generation? 24-39%. 🔴 The AI users felt it, too. Several described themselves as feeling "lazy" and wished they'd engaged more deeply with the material. To be clear, the finding isn't "don't use AI." It's that delegation and learning are fundamentally different activities — and most developers are defaulting to delegation. If you want to get the best of speed AND learning, consider these ideas: 1️⃣ Separate performance tasks from learning tasks. When your team already knows the domain, let AI accelerate delivery. When they're onboarding to something new, encourage AI for explanations and conceptual questions. 2️⃣ Stop optimizing away all friction. Debugging isn't all wasted time — it's where understanding forms. That investment comes in handy when you're trying to debug a P0 in production or explain logic to business leaders. 3️⃣ Coach high-signal interaction patterns. "Explain how this concurrency model works" produces very different outcomes than "write the function for me." We obsess over how fast AI helps developers ship, but we should think slightly longer term about the impact of that speed, and what it means for long-term learning and retention. Full research breakdown in this week's RDEL (link in comments). How is your team balancing AI speed with skill development?

Most developers use AI to write code faster. The best ones use it to stop writing code entirely. Today, I spend 80% of my time describing what I want, reviewing what agents build, and deciding when to step in. The other 20% is architecture and security calls that agents can't make yet. This isn't lazy. It's the new job. Anthropic's 2026 Agentic Coding Trends Report confirmed what I've been feeling: developers now integrate AI into 60% of their work while maintaining active oversight on 80-100% of delegated tasks. The role shifted from "person who writes code" to "person who directs and reviews code." Here are 5 skills I had to learn the hard way: 𝟭. 𝗪𝗿𝗶𝘁𝗶𝗻𝗴 𝗦𝗽𝗲𝗰𝘀, 𝗡𝗼𝘁 𝗖𝗼𝗱𝗲 The quality of what an agent builds is directly proportional to how well you describe what you want. Vague prompt = vague code. I now spend more time writing specs than I ever spent writing implementations. 𝟮. 𝗧𝗮𝘀𝗸 𝗗𝗲𝗰𝗼𝗺𝗽𝗼𝘀𝗶𝘁𝗶𝗼𝗻 Agents lose context on large tasks and waste time on tiny ones. The skill is finding the sweet spot: chunks big enough to be meaningful, small enough to stay accurate. 𝟯. 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 Agents forget everything between sessions. Your project rules, memory files, and AGENTS .md are what give them continuity. This is the most underrated skill on the list. 𝟰. 𝗥𝗲𝘃𝗶𝗲𝘄𝗶𝗻𝗴 𝗔𝗜 𝗢𝘂𝘁𝗽𝘂𝘁 Agents generate code fast. They also generate security holes, edge case gaps, and subtle architectural drift fast. Your job is catching what they miss. This is harder than writing the code yourself. 𝟱. 𝗞𝗻𝗼𝘄𝗶𝗻𝗴 𝗪𝗵𝗲𝗻 𝘁𝗼 𝗦𝘁𝗲𝗽 𝗜𝗻 Architecture decisions and security calls are still yours. Everything else? Let the agent iterate. The hardest part isn't learning to delegate. It's learning to stop grabbing the keyboard back. The developers who thrive in 2026 won't be the fastest coders. They'll be the best agent operators. Which of these 5 are you already doing?

Agent-assisted coding transformed my workflow. Most folks aren’t getting the full value from coding agents—mainly because there’s not much knowledge sharing yet. Curious how to unlock more productivity with AI agents? Here’s what’s worked for me. After months of experimenting with coding agents, I’ve noticed that while many people use them, there’s little shared guidance on how to get the most out of them. I’ve picked up a few patterns that consistently boost my productivity and code quality. Iterating 2-3 times on a detailed plan with my AI assistant before writing any code has saved me countless hours of rework. Start with a detailed plan—work with your AI to outline implementation, testing, and documentation before coding. Iterate on this plan until it’s crystal clear. Ask your agent to write docs and tests first. This sets clear requirements and leads to better code. Create an "AGENTS.md" file in your repo. It’s the AI’s university—store all project-specific instructions there for consistent results. Control the agent’s pace. Ask it to walk you through changes step by step, so you’re never overwhelmed by a massive diff. Let agents use CLI tools directly, and encourage them to write temporary scripts to validate their own code. This saves time and reduces context switching. Build your own productivity tools—custom scripts, aliases, and hooks compound efficiency over time. If you’re exploring agent-assisted programming, I’d love to hear your experiences! Check out my full write-up for more actionable tips: https://lnkd.in/eSZStXUe What’s one pattern or tool that’s made your AI-assisted coding more productive? #ai #programming #productivity #softwaredevelopment #automation

If you find yourself constantly refactoring AI-generated code, you are skipping the most important step: The Conversation. Here’s the workflow that gives me high-quality code on the first write to disk: 1. Start with a conversation, not code • Explain the problem to the LLM in detail. • Tell it explicitly: “Propose an approach first. Show alternatives. Do not write code until I approve.” • Review the proposal, poke holes in it, iterate, then let it generate code. Treat it like a cognitive power tool, not an autocomplete. 2. Pick models that actually follow instructions • In my experience, GPT-5 high variant with codex is the best at respecting constraints and following “do not code yet” style directives. • Claude Sonnet 4.5 and Claude Opus 4 are solid runner-ups. • Many other models tend to ignore “do not code” and sneak in extra stuff you never asked for. 3. Set your coding standards once • Have something like a Claude/Agents.md (or equivalent system prompt) that defines: • Coding style • Architecture preferences • Clean code principles This becomes your reusable “engineering brain” the model loads every time that writes high quality code by default. 4. Control your context size • Don’t let the thread get bloated. • Use commands like /compact (or your tool’s equivalent) frequently. • Long, noisy context = degraded output quality. This workflow has made my coding sessions faster, more predictable, and has dramatically reduced the amount of refactoring I need to do because all the guidance is given up front.

AI coding LLMs and tools are improving rapidly. There is a massive amount of value and velocity teams can unlock by using them correctly. One reminder I recently shared internally at Productboard that’s worth repeating more broadly👇 It’s critical to start with a strong product specification. Spend the first 1–2 hours iterating on the spec definition to ensure all requirements are clear and there are no surprises mid-implementation. A few practical tips on how to do that: 🔹 Paste (or even better, pull via MCP) the specs you got from your PM into a Markdown file 🔹 Ask Claude: “Ask me any questions needed to make sure you deeply understand the feature we will be building.” You might get 40–60 questions back - ideally use something like WhisperFlow so you don’t spend the next two hours just answering them 🔹 Ask Claude: “Propose three very different approaches to building this feature and explain their pros and cons in terms of complexity, maintainability, and user value.” Then iterate toward the approach that makes the most sense 🔹 Ask Claude: “Research the codebase, put together an implementation plan for this feature, and come back with additional product questions that need to be answered before implementation.” Context engineering is just as critical. A few tips there: 🔹 Use a “Research → Plan → Implement” staged flow, fully wiping the context window between each stage instead of relying on automatic compaction 🔹 Spend significant time reading, reviewing, and adjusting the outputs of each stage 🔹 Use research sub-agents heavily - you may need to explicitly prompt for this depending on the tool and LLM you’re using When it comes to implementation quality: 🔹 Make sure you truly understand every line of code you push into a PR 🔹 Having the agent walk you through the changes and explain non-obvious parts (especially around libraries or frameworks) is often a great idea Tooling matters more than ever: 🔹 Make sure you deeply understand the features and tricks of the coding tools you use - not easy when tools like Claude Code and Cursor ship updates almost daily 🔹 Invest in AI tooling configuration in your repos 🔹 Invest in better linters - the best teams are often doubling the number of linter rules compared to pre-AI days, giving agents fast and precise feedback 🔹 Constantly update your AGENTS.md / Claude.md files as you notice behaviors that should be adjusted - top teams update these almost daily And finally: 🔹 Share your tips and tricks with colleagues How are you and your teams approaching AI-assisted coding today? What practices have made the biggest difference for you so far?