Iterative Coding Strategies for Software Development

In the last few months, I have explored LLM-based code generation, comparing Zero-Shot to multiple types of Agentic approaches. The approach you choose can make all the difference in the quality of the generated code. Zero-Shot vs. Agentic Approaches: What's the Difference? ⭐ Zero-Shot Code Generation is straightforward: you provide a prompt, and the LLM generates code in a single pass. This can be useful for simple tasks but often results in basic code that may miss nuances, optimizations, or specific requirements. ⭐ Agentic Approach takes it further by leveraging LLMs in an iterative loop. Here, different agents are tasked with improving the code based on specific guidelines—like performance optimization, consistency, and error handling—ensuring a higher-quality, more robust output. Let’s look at a quick Zero-Shot example, a basic file management function. Below is a simple function that appends text to a file: def append_to_file(file_path, text_to_append): try: with open(file_path, 'a') as file: file.write(text_to_append + '\n') print("Text successfully appended to the file.") except Exception as e: print(f"An error occurred: {e}") This is an OK start, but it’s basic—it lacks validation, proper error handling, thread safety, and consistency across different use cases. Using an agentic approach, we have a Developer Lead Agent that coordinates a team of agents: The Developer Agent generates code, passes it to a Code Review Agent that checks for potential issues or missing best practices, and coordinates improvements with a Performance Agent to optimize it for speed. At the same time, a Security Agent ensures it’s safe from vulnerabilities. Finally, a Team Standards Agent can refine it to adhere to team standards. This process can be iterated any number of times until the Code Review Agent has no further suggestions. The resulting code will evolve to handle multiple threads, manage file locks across processes, batch writes to reduce I/O, and align with coding standards. Through this agentic process, we move from basic functionality to a more sophisticated, production-ready solution. An agentic approach reflects how we can harness the power of LLMs iteratively, bringing human-like collaboration and review processes to code generation. It’s not just about writing code; it's about continuously improving it to meet evolving requirements, ensuring consistency, quality, and performance. How are you using LLMs in your development workflows? Let's discuss!

Whether you're using Replit Agent, Assistant, or other AI tools, clear communication is key. Effective prompting isn't magic; it's about structure, clarity, and iteration. Here are 10 principles to guide your AI interactions: 🔹 Checkpoint: Build iteratively. Break down large tasks into smaller, testable steps and save progress often. 🔹 Debug: Provide detailed context for errors – error messages, code snippets, and what you've tried. 🔹 Discover: Ask the AI for suggestions on tools, libraries, or approaches. Leverage its knowledge base. 🔹 Experiment: Treat prompting as iterative. Refine your requests based on the AI's responses. 🔹 Instruct: State clear, positive goals. Tell the AI what to do, not just what to avoid. 🔹 Select: Provide focused context. Use file mentions or specific snippets; avoid overwhelming the AI. 🔹 Show: Reduce ambiguity with concrete examples – code samples, desired outputs, data formats, or mockups. 🔹 Simplify: Use clear, direct language. Break down complexity and avoid jargon. 🔹 Specify: Define exact requirements – expected outputs, constraints, data formats, edge cases. 🔹 Test: Plan your structure and features before prompting. Outline requirements like a PM/engineer. By applying these principles, you can significantly improve your collaboration with AI, leading to faster development cycles and better outcomes.

More thoughts on Claude Code, prompted by Laura F. (thanks!): This is how I get higher quality results from Claude. By default, agentic / "vibe" coding can give you "good enough" code that gets the job done, but might be hard to maintain. Good software design and guidance to the AI is the key - AKA good software leadership 😄 The method I use is a modified form of what I do in my day job. I was a startup CTO for 10 years and have been an enterprise tech executive for the last 5. This approach delivers results, with people or AI! 1. Build a detailed high level design that describes the application and its major components, what major technical choices you want to make, and why. Include constraints and reasoning for decision making. 2. Validate the design with engineering spikes as necessary. Save the spikes for later reference and document your learnings. 3. Use the data you collected along with public documentation to build a series of low level designs, one per major component or system in the product. Validate the hell out of these designs! Make sure they clarify technical details of what needs to be built and that they show particularly tricky algorithms or technical choices in the design. Include diagrams, data designs, UX design, and a testing strategy. This phase is the most critical one to get right! When the context window gets compacted, these docs bring the AI back up to speed. 4. Build a project plan and break the work into milestones and sprints. Make sure the build order is correct. 5. Start building, but write tests first! Claude will default to just build code. Be clear that tests must come first, so you can know if you're moving in the right direction and not introduce regressions. You'll need to remind the AI throughout the process on this one. 6. Have Claude check what it's built against the low-level design docs frequently. Claude will diverge from the plan! You will also probably find that you want to change the plan. When you do, take the time to update the design docs. These docs are the beating heart of your product. They're truth, keep them true. 7. Iterate 😄 It'll take some time but this formula is working for me. Pro tip: When Claude gets stuck (throwing ideas at the wall, going in circles): Switch to plan mode, have it look up docs / blogs and see what others are doing. Or, start a fresh session. Sometimes Claude gets tunnel vision. I'd love to learn your tips too! 🎉

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

You know the old game Scorched Earth. You aim, dial in a velocity, fire. Sometimes you hit. Usually you miss. You adjust. Fire again. After a few rounds you haven't just gotten closer — you've built a blueprint for where to aim. AI coding agents work a lot like this. Most developers skip the tracer shots. When you start digging into people's Claude Code workflow you'll find a recurring principle: never let the model write code until you've reviewed and approved a written plan. Notably, both of my favorite agentic development frameworks — GitHub's Spec Kit and Every's Compound Engineering seem to have independently arrived at the same structure. Write before you code. Plan as a living document. Never let the agent jump to implementation. The most expensive failure mode isn't wrong code. It's implementations that work in isolation but break the surrounding system, a function that ignores an existing caching layer, a migration that misses the ORM's conventions, an endpoint that duplicates logic that already exists elsewhere. The fix is a research phase first. Ask the model to read the relevant codebase and write its findings to a persistent research.md. This gives you project back context that you can open, read, and correct before any planning happens. Then comes the annotation cycle — where the real leverage lives. Ask for a detailed implementation plan in plan.md. Then open it in your editor and add inline notes directly in the document. Not in chat. Right next to what's wrong. Repeat one to six times. Each round is a tracer shot. You're not firing for effect, instead, you're dialing in. And crucially, you're building an artifact that describes exactly what you were trying to achieve. A blueprint that survives the session and gives you something to point at later. By the time you say implement, every decision has been made. Implementation should be boring. The creative work happened in the annotation cycles. Wonderfully, this also means the human developer got better at understanding and architecting the system AND you can build with Sonnet instead of Opus. It's nearly a win win win. Three independent frameworks. Same structure. That convergence means something. Once you've worked this way, you'll wonder how you ever shipped anything with coding agents without an annotated plan document sitting between you and the code.