How AI can Improve Coding Tasks

RIP coding? OpenAI has just introduced Codex — a cloud-based AI agent that autonomously writes features, fixes bugs, runs tests, and even documents code. Not just autocomplete, but a true virtual teammate. This marks a shift from AI-assisted to AI-autonomous software engineering. The implications are profound. We’re entering an era where writing code can be done by simply explaining what you want in natural language. Tasks that once required hours of development can now be executed in parallel by an AI agent — securely, efficiently, and with growing precision. So, what does this mean for human skills? The value is shifting fast: → From execution to architecture and design thinking → From code writing to problem framing and solution oversight → From syntax knowledge to strategic understanding of systems, ethics, and user needs As Codex and other agentic AIs evolve, the most critical skills will be, at least for SW tech roles: • AI literacy: knowing what agents can (and cannot) do • Prompt engineering and task orchestration • System design & creative problem solving • Human judgment in code quality, security, and governance It’s a new world for solo founders, tech leads, and enterprise innovation teams alike. We won’t need fewer people. We’ll need people with new skills — ready to lead in an agent-powered era. Let’s embrace the shift. The real opportunity isn’t in writing code faster — it’s in rethinking what we build, how we build, and why. #AI #Codex #FutureOfWork #SoftwareEngineering #AgenticAI #Leadership #AIAgents #TechTrends

AI coding assistants are changing the way software gets built. I've recently taken a deep dive into three powerful AI coding tools: Claude Code (Anthropic), OpenAI Codex, and Cursor. Here’s what stood out to me: Claude Code (Anthropic) feels like a highly skilled engineer integrated directly into your terminal. You give it a natural language instruction, like a bug to fix or a feature to build and it autonomously reads through your entire codebase, plans the solution, makes precise edits, runs your tests, and even prepares pull requests. Its strength lies in effortlessly managing complex tasks across large repositories, making it uniquely effective for substantial refactors and large monorepos. OpenAI Codex, now embedded within ChatGPT and also accessible via its CLI tool, operates as a remote coding assistant. You describe a task in plain English, it uploads your project to a secure cloud sandbox, then iteratively generates, tests, and refines code until it meets your requirements. It excels at quickly prototyping ideas or handling multiple parallel tasks in isolation. This approach makes Codex particularly powerful for automated, iterative development workflows, perfect for agile experimentation or rapid feature implementation. Cursor is essentially a fully AI-powered IDE built on VS Code. It integrates deeply with your editor, providing intelligent code completions, inline refactoring, and automated debugging ("Bug Bot"). With real-time awareness of your codebase, Cursor feels like having a dedicated AI pair programmer embedded right into your workflow. Its agent mode can autonomously tackle multi-step coding tasks while you maintain direct oversight, enhancing productivity during everyday coding tasks. Each tool uniquely shapes development: Claude Code excels in autonomous long-form tasks, handling entire workflows end-to-end. Codex is outstanding in rapid, cloud-based iterations and parallel task execution. Cursor seamlessly blends AI support directly into your coding environment for instant productivity boosts. As AI continues to evolve, these tools offer a glimpse into a future where software development becomes less about writing code and more about articulating ideas clearly, managing workflows efficiently, and letting the AI handle the heavy lifting.

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

Last week, I described four design patterns for AI agentic workflows that I believe will drive significant progress: Reflection, Tool use, Planning and Multi-agent collaboration. Instead of having an LLM generate its final output directly, an agentic workflow prompts the LLM multiple times, giving it opportunities to build step by step to higher-quality output. Here, I'd like to discuss Reflection. It's relatively quick to implement, and I've seen it lead to surprising performance gains. You may have had the experience of prompting ChatGPT/Claude/Gemini, receiving unsatisfactory output, delivering critical feedback to help the LLM improve its response, and then getting a better response. What if you automate the step of delivering critical feedback, so the model automatically criticizes its own output and improves its response? This is the crux of Reflection. Take the task of asking an LLM to write code. We can prompt it to generate the desired code directly to carry out some task X. Then, we can prompt it to reflect on its own output, perhaps as follows: Here’s code intended for task X: [previously generated code] Check the code carefully for correctness, style, and efficiency, and give constructive criticism for how to improve it. Sometimes this causes the LLM to spot problems and come up with constructive suggestions. Next, we can prompt the LLM with context including (i) the previously generated code and (ii) the constructive feedback, and ask it to use the feedback to rewrite the code. This can lead to a better response. Repeating the criticism/rewrite process might yield further improvements. This self-reflection process allows the LLM to spot gaps and improve its output on a variety of tasks including producing code, writing text, and answering questions. And we can go beyond self-reflection by giving the LLM tools that help evaluate its output; for example, running its code through a few unit tests to check whether it generates correct results on test cases or searching the web to double-check text output. Then it can reflect on any errors it found and come up with ideas for improvement. Further, we can implement Reflection using a multi-agent framework. I've found it convenient to create two agents, one prompted to generate good outputs and the other prompted to give constructive criticism of the first agent's output. The resulting discussion between the two agents leads to improved responses. Reflection is a relatively basic type of agentic workflow, but I've been delighted by how much it improved my applications’ results. If you’re interested in learning more about reflection, I recommend: - Self-Refine: Iterative Refinement with Self-Feedback, by Madaan et al. (2023) - Reflexion: Language Agents with Verbal Reinforcement Learning, by Shinn et al. (2023) - CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing, by Gou et al. (2024) [Original text: https://lnkd.in/g4bTuWtU ]

💡Most AI coding tools are getting better at generating code. But that is not where the real bottleneck is. The hardest part is not writing code. It is executing real workflows across complex systems. I’ve tinkered with Qoder and QoderWork in real workflows recently, and this gap becomes very obvious in practice. If you talk to enough engineers, you start hearing the same story: Code suggestions are cheap. Context is not. Execution is even harder. Specs live in documents. Code lives in repositories. Workflows live across tools. And engineers are left stitching everything together. This is the gap most AI tools still do not solve. They generate - but they do not execute. We are starting to see a shift: From AI as suggestion engines to AI as execution systems. What makes Qoder different is its Spec-Driven workflow. Instead of treating specs as passive documentation, Qoder turns them into the starting point of execution. In Quest Mode, the system first aligns on requirements, generates a structured spec with task breakdowns and acceptance criteria, and then autonomously executes and verifies each step. No vague prompts. No guesswork. Just traceable, production-ready delivery. That is what I find interesting about Qoder. Not just another coding assistant, but an attempt to build an agentic coding platform for real engineering teams. What this means in practice: 🔹Understanding large, real-world codebases across thousands of files 🔹Breaking specs into structured tasks with clear acceptance criteria 🔹Executing tasks in parallel environments 🔹Delivering outputs that are actually usable in production You can test it on a 500-file TypeScript monorepo — Qoder’s RepoWiki will index the entire codebase, mapped dependencies across modules, and the agent completed a cross-module refactor that would have taken me hours. And importantly, this is designed for teams and enterprise environments. Not just individual developers experimenting in isolation, but engineering organizations that need to ship reliably at scale. And beyond engineering, QoderWork pushes this even further. Turning AI from something that “helps” into something that actually completes real business workflows. From working with local files to automating repetitive knowledge work across teams. For example, you can use QoderWork to process a batch of local PDFs — extracting key insights, structuring them into a report, and organizing outputs automatically. Instead of manually coordinating multiple steps, the agent handled the workflow end-to-end. This is not a tooling upgrade. It is a shift in how work gets done. The question is no longer: Can AI generate code? It is: Can AI take a spec and ship something usable end-to-end? Explore how agentic AI moves from suggestions to real execution: 👉https://aisecret.co/greg Where does your workflow still break down — generation, context, or execution? #Qoder #QoderWork #AgenticCoding #EnterpriseAI #DevTools #AIProductivity

How well does AI write code? According to medalist judges, AI’s code is not so great. But there were a few surprises buried in this paper. This is the most critical and comprehensive analysis of AI coding agents so far. I expected Claude 3.7 to be near the top, but OpenAI’s o4 and Gemini 2.5 Pro scored significantly higher. Both can solve most coding problems that the judges ranked as ‘Easy’, and the solutions cost pennies to generate. OpenAI’s o4-mini-high delivered solutions that only required human interventions 17% of the time for $0.11. Compare that to the cost of a software engineer implementing the solution, and the benefits are obvious. It generated complete implementations for medium problems 53% of the time, also at a significant cost savings. However, its reliability drops to 0 for hard problems. Researchers found that AI coding assistants are exceptionally useful if they are given access to the right tools and focused on simple or medium difficulty problems. With tools and multiple attempts, solution accuracy doubled for some LLMs, and they were able to solve a small number of hard problems. However, programming skills and software engineers are still required. AI coding tool users must be able to identify flawed implementations and know how to fix them. Even with tools and multiple attempts, AI coding assistants still fumble problems at all difficulty levels. Code reviews and validation continue to be critical parts of the workflow, so the hype of vibe-coding and AI replacing software engineers is still just a myth. At the same time, the software engineering workflow is changing dramatically. Multiple researchers have attempted to determine how much code is written by AI vs. people, but accurate classification methods are proving elusive. At the same time, research like this makes the trend undeniable. $0.11 per implementation represents a cost savings that businesses won’t pass up. The future of software engineering is AI augmented. An increasing amount of code will be written by AI and validated by people. Most code required to implement a feature falls into the medium or easy category. AI coding assistants can’t do the most valuable work, but their impact on the time it takes to deliver a feature will be bigger than the benchmarks indicate. Now that we’re seeing research into the root causes of implementation failure, like this paper, expect AI coding tools to accelerate their capabilities development rate in the next two years. For everyone in a technical role, it’s time to think about how to adapt and best position yourself for the next 5-10 years.

𝗗𝗼 𝗔𝗜 𝗖𝗼𝗱𝗶𝗻𝗴 𝗔𝘀𝘀𝗶𝘀𝘁𝗮𝗻𝘁𝘀 𝗥𝗲𝗮𝗹𝗹𝘆 𝗕𝗼𝗼𝘀𝘁 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 𝗣𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝘃𝗶𝘁𝘆? 𝗔 𝗥𝗲𝗮𝗹𝗶𝘁𝘆 𝗖𝗵𝗲𝗰𝗸 𝗳𝗿𝗼𝗺 800+ 𝗚𝗶𝘁𝗛𝘂𝗯 𝗣𝗿𝗼𝗷𝗲𝗰𝘁𝘀 New research from Carnegie Mellon University just dropped and the results are fascinating. The team studied the impact of 𝗖𝘂𝗿𝘀𝗼𝗿, a popular LLM-based agentic IDE, across 807 real-world repositories using causal inference methods. 𝗛𝗲𝗿𝗲’𝘀 𝘄𝗵𝗮𝘁 𝘁𝗵𝗲𝘆 𝗳𝗼𝘂𝗻𝗱: 𝗩𝗲𝗹𝗼𝗰𝗶𝘁𝘆 gains are real, but 𝘀𝗵𝗼𝗿𝘁-𝗹𝗶𝘃𝗲𝗱 - +281% more code in month 1 - +48% in month 2 - Back to baseline after that 𝗖𝗼𝗱𝗲 𝗾𝘂𝗮𝗹𝗶𝘁𝘆 𝘁𝗮𝗸𝗲𝘀 𝗮 𝗵𝗶𝘁 and it sticks - +30% static analysis warnings - +41% increase in code complexity - Long-term slowdown due to accumulated tech debt => 𝗦𝗲𝗹𝗳-𝗿𝗲𝗶𝗻𝗳𝗼𝗿𝗰𝗶𝗻𝗴 𝗰𝘆𝗰𝗹𝗲: 𝗠𝗼𝗿𝗲 𝗰𝗼𝗱𝗲 -> 𝗠𝗼𝗿𝗲 𝗰𝗼𝗺𝗽𝗹𝗲𝘅𝗶𝘁𝘆 -> 𝗦𝗹𝗼𝘄𝗲𝗿 𝗽𝗿𝗼𝗴𝗿𝗲𝘀𝘀 LLM coding agents like Cursor can supercharge productivity, for a moment. But without process changes, they may speed you toward an unmaintainable codebase. 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆: Build in quality assurance from day one. Test coverage, refactoring sprints, smarter prompts. AI won’t save your codebase unless you save it first. #AI #LLM #SoftwareEngineering #Productivity #TechDebt

On Sunday, I used AI to build an app that generated 23,000 lines of code in a couple of hours. On Monday, I posted about the experience, including the mistakes the AI made. My point: AI can build most of a tool fast, but you still need solid software engineering skills to ship a working product. Oddly, a bunch of software engineers jumped in to tell me I was using AI wrong. If I'd just followed better software engineering practices, they said, it would've worked perfectly. The irony? That was exactly my point. You need software engineering practices, knowledge and skills to get the most from AI. So for those that missed it, I've been documenting my views on AI-assisted coding. I believe in strong opinions, weakly held, so I'd like thoughts, feedback, and challenges to the following opinions. On AI and AI-Assisted Coding: → The agent harness largely shouldn’t matter. The process should work with all of them. → Most AI-assisted coding processes are too complex. They clutter the context window with unnecessary MCP tools, skills, or content from the AGENTS file. → A small, tightly defined, and focused context window produces the best results. → LLMs do not reason, they do not think, they are not intelligent. They're simple text prediction engines. Treat them that way. → LLMs are non-deterministic. That doesn't matter as long as the process provides deterministic feedback: compiler warnings as errors, linting, testing, and verifiable acceptance criteria. → Don't get attached to the code. Be prepared to revert changes and retry with refinements to the context. → Fast feedback helps. Provide a way for an LLM to get feedback on its work. → Coding standards and conventions remain useful. LLMs have been trained on code that follows common ones and to copy examples in their context. When your code align with those patterns, you get better results. On Software Development: → Work on small defined tasks. → Work with small batch sizes. → Do the simplest possible thing that meets the requirements. → Use TDD. → Make small atomic commits. → Work iteratively. → Refactor when needed. → Integrate continuously. → Trust, but verify. → Leverage tools. What are your strong opinions on AI-assisted coding?

I spent 4x more time on code quality than on building new features. And I still doubled my productivity! Wait, what? That's the result from a 2-month experiment I ran with production code. Not a side project, not a demo -- real systems, real users, real stakes. I tracked everything: refactoring, cleanup, deleting code, introducing tests, improving testability, security analysis. The ratio was roughly 4:1 quality-to-features. Here's what I found: Fast feedback loops change everything. With AI-assisted coding, I could implement a change, review it, run security analysis, prioritize next steps, and iterate -- all within an hour. That compression made quality investment feel cheap instead of expensive. Deleting code is a superpower. I removed every feature that wasn't being used (based on usage data!). Each removal simplified the architecture. Each simplification made the next change faster. It became a positive spiral -- less code, more speed. Preparation beats generation. Instead of asking "write me this feature," I started asking "how should I change my system to make this feature trivially easy to introduce?" (your questions define your impact!) Make the change easy, then make the easy change. AI makes that preparation almost free. The uncomfortable truth: AI is an amplifier. Engineers who already build software well will build it faster. Engineers who don't will generate technical debt at a pace we've never seen before. I shared the full experiment and the numbers on the @ScrumPodcast with Vasco Duarte.  Listen here: https://lnkd.in/eyHiR7QD #AIAssistedCoding #SoftwareEngineering #CodeQuality #XP #DevOps #TechnicalExcellence

Quality over quantity - this mantra has never been more critical than in the age of AI-assisted coding. Here's why we need to shift our focus from code proliferation to code excellence. The temptation with current AI coding tools is clear: generate more code, faster. But having led large-scale software projects, I can tell you that more code often means more problems. The real challenge isn't writing code - it's writing the right code. Consider these statistics: - The average enterprise maintains millions of lines of code - Technical debt costs companies an estimated 20-40% of their development time - Software failures cost the US economy $2.4 trillion annually True AI assistance should help us: - Identify opportunities for code reuse rather than duplication - Recognize when code can be eliminated entirely - Understand and maintain architectural integrity - Enforce best practices and coding conventions - Guide strategic evolution of the codebase The next frontier isn't about generating more code - it's about generating better code. This means AI that can recognize patterns, suggest optimizations, and help teams make strategic decisions about their codebase evolution. What if your AI assistant could help port performance-critical systems to more efficient languages, or identify opportunities to improve your data model? What if it could help reduce your technical debt while adding new features? What if it actually wanted to delete rather than add code? Augment Code #SoftwareQuality #TechnicalDebt #AIinDevelopment #AI