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!

You build a RAG system. It’s accurate. It’s grounded. You’re proud of it. But then you look at the stopwatch. 𝟏𝟐 𝐬𝐞𝐜𝐨𝐧𝐝𝐬. You watch the loading spinner on your demo screen for what feels like an eternity. You know deep down that no real user, not a customer, not an employee will wait 12 seconds for an answer they could have Googled in 3. 𝐈𝐧 𝐩𝐫𝐨𝐝𝐮𝐜𝐭𝐢𝐨𝐧, 𝐥𝐚𝐭𝐞𝐧𝐜𝐲 𝐢𝐬 𝐣𝐮𝐬𝐭 𝐚𝐬 𝐢𝐦𝐩𝐨𝐫𝐭𝐚𝐧𝐭 𝐚𝐬 𝐚𝐜𝐜𝐮𝐫𝐚𝐜𝐲. If your AI is slow, it’s broken. Most 𝐁𝐞𝐠𝐢𝐧𝐧𝐞𝐫 𝐀𝐈 𝐏𝐫𝐨𝐟𝐞𝐬𝐬𝐢𝐨𝐧𝐚𝐥𝐬 hit this "Performance Wall" because they treat the AI pipeline like a sequential script rather than a distributed system. 𝐇𝐨𝐰 𝐭𝐨 𝐤𝐢𝐥𝐥 𝐥𝐚𝐭𝐞𝐧𝐜𝐲 𝐢𝐧 𝐏𝐫𝐨𝐝𝐮𝐜𝐭𝐢𝐨𝐧-𝐆𝐫𝐚𝐝𝐞 𝐀𝐈: 1. 𝐒𝐞𝐦𝐚𝐧𝐭𝐢𝐜 𝐂𝐚𝐜𝐡𝐢𝐧𝐠: Don't hit the LLM for the same question twice. Use a vector cache (like Redis) to store and retrieve semantically similar queries in sub-100ms. 2. 𝐒𝐭𝐫𝐞𝐚𝐦𝐢𝐧𝐠 𝐑𝐞𝐬𝐩𝐨𝐧𝐬𝐞𝐬: Stop waiting for the whole paragraph to generate. Use Server-Sent Events (SSE) to stream tokens to the user the millisecond they are ready. It makes the "perceived" latency feel near-zero. 3. 𝐏𝐚𝐫𝐚𝐥𝐥𝐞𝐥 𝐑𝐞𝐭𝐫𝐢𝐞𝐯𝐚𝐥: While the LLM is "thinking" about the prompt, your system should be pre-fetching metadata or clearing the cache. Every millisecond counts. 4. 𝐌𝐨𝐝𝐞𝐥 𝐐𝐮𝐚𝐧𝐭𝐢𝐳𝐚𝐭𝐢𝐨𝐧: You don't always need the "Full" model. Using a quantized version (INT8 or FP8) can cut inference time by 50% with almost zero loss in intelligence. I realized this shift when I moved from building simple wrappers to managing 𝐞𝐧𝐭𝐞𝐫𝐩𝐫𝐢𝐬𝐞-𝐠𝐫𝐚𝐝𝐞 𝐢𝐧𝐟𝐫𝐚𝐬𝐭𝐫𝐮𝐜𝐭𝐮𝐫𝐞 A 12-second response isn't an "AI problem"; it’s a 𝐬𝐲𝐬𝐭𝐞𝐦 𝐝𝐞𝐬𝐢𝐠𝐧 𝐟𝐚𝐢𝐥𝐮𝐫𝐞 𝐒𝐮𝐜𝐜𝐞𝐬𝐬 𝐢𝐧 𝐀𝐈 𝐢𝐬𝐧'𝐭 𝐣𝐮𝐬𝐭 𝐚𝐛𝐨𝐮𝐭 𝐭𝐡𝐞 "𝐁𝐫𝐚𝐢𝐧." 𝐈𝐭’𝐬 𝐚𝐛𝐨𝐮𝐭 𝐭𝐡𝐞 "𝐍𝐞𝐫𝐯𝐨𝐮𝐬 𝐒𝐲𝐬𝐭𝐞𝐦" (𝐓𝐡𝐞 𝐏𝐢𝐩𝐞𝐥𝐢𝐧𝐞). Users forgive a slight error, but they never forgive a slow interface. If you aren't measuring TTFT (Time to First Token), you aren't building for production.

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?

I started coding again when the first ChatGPT launched in November 2022—curiosity turned into obsession. Since then, I’ve tried nearly every AI coding tool out there. Recently, I’ve become hooked on Cursor. It’s common to see two extremes: • New/junior devs often overestimate what AI can do. • Senior engineers usually distrust it entirely. Both are wrong! The sweet spot is using AI as an empowering partner, not a full dev replacement. You’re still in control—AI can help you go faster and think deeper, but only if you stay in the loop. After months of heavy use, here are some practical tips and a prompt sequence I rely on for deep code reviews and debugging in Cursor 👇 ⸻ 🔁 1. LLMs have no memory. Every chat is stateless. If you close the tab or start a new thread, you must reintroduce the code context—especially for complex systems. 📌 2. Think in steps, not monolith prompts. Work in multi-step prompts within the same chat session. Review each output before proceeding. ⚠️ 3. LLMs tend to do more than asked. Start by asking: “What are you going to do?” Then approve and ask: “Now do only that.” 💾 4. Commit before you go. Save your last working state. AI edits can be powerful—and sometimes destructive. 🧠 5. Use the right model for the job. • Lightweight stuff → Sonnet 4 • Deep analysis or complex refactoring → Opus 4 or O3 (these cost more, but they’re worth it) ⸻ 👨💻 Prompt Workflow Example: Reviewing a Complex App with Legacy Code Here’s a sequence I use inside a single Cursor chat session: ⸻ 🧩 Prompt 1 “As a senior software architect, review this app. Focus on [e.g. performance, architecture, state management, UI]. Provide an .md doc with findings, code diagrams, and flow logic.” ✅ Carefully review what’s generated. Correct or expand anything that feels off. Save it for reuse. ⸻ 🔍 Prompt 2 “Based on this understanding, identify the top 5 most critical issues in the app—explain their impact and urgency.” Ask for clarification or expansion if needed. ⸻ 💡 Prompt 3 “For issue #3, suggest 2–3 possible solutions (no code yet). For each, list pros/cons and outline what needs to change.” Choose the most viable solution. ⸻ 🛠️ Prompt 4 “Now implement the selected solution step by step. After each step, run ESLint (and if available, unit tests).” ⸻ 🔬 Pro tip: Ask Cursor to generate a full unit test suite before editing. Then validate every change via tests + linting. ⸻ This is how I use AI coding tools today: as a thought partner and execution aid, not a replacement. Would love to hear your workflows too. #CursorIDE #PromptEngineering l #DeveloperTips #CodingWithAI

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