Marek Pavilovič’s Post

Agentic Coding Best Practices: Level Up Your SDD for Smarter, Faster Development In the era of AI agents, Agentic Coding isn't just hype—it's transforming how we build software. But without solid Software Design Documents (SDDs), it's chaos. Here's how to make SDDs your secret weapon for end-to-end excellence, with a heavy focus on testing (manual and automated). 1. Craft Full-Functional User Stories in Your SDD Start with crystal-clear user stories that cover every functional angle. This isn't a vague outline—it's your blueprint. Agents thrive on specificity, turning stories into executable plans. 2. Master Testing: Manual First, Then Hyper-Automate Manual Testing as the Foundation: Use your SDD's BDD specs (Given-When-Then) for targeted manual exploratory testing. Humans excel at UX intuition, edge-case discovery, and subjective validation—run quick sessions to validate agent-generated code against real-world flows. Limit to 20% of effort; agents handle the rest to avoid bottlenecks. Automated Testing Revolution: Leverage AI agents for test case generation straight from SDD stories—scanning requirements to auto-create comprehensive suites (unit, integration, E2E) with 70% less manual work. Tools like agentic frameworks expand one story into dozens of scenarios via NLU and systematic variations. Implementation with Selenium or Playwright:   - Playwright (preferred 2026): 2-3x faster execution (45s vs 90s per suite), 60% fewer flakes, built-in parallelism, and auto-waits. Ideal for cross-browser/device E2E tests.[3] - Selenium: Mature for complex Grid setups, but higher resource use (500MB memory vs 250MB).   Integrate into CI/CD: Agents write/run tests, enforcing 100% coverage. Result? 50% faster releases, 40-60% fewer bugs in prod. 3. Build Custom Skill Agents per Tech Stack Don't use one-size-fits-all agents. Create specialized agents for React, Node.js, AWS, etc.—trained on your SDD. They handle stack-specific tasks like optimizing queries or securing endpoints, slashing context-switching by 50%. 4. Design Guardrails & Gardens Around Your Framework Define strict guardrails (e.g., "Never use raw SQL; always ORM") and sandbox gardens (safe zones for experimentation). Agents respect these, ensuring compliance while fostering innovation. Your SDD enforces this—no more rogue code. 5. End-to-End Process: From SDD to Prod - Plan: SDD with stories + BDD specs.   - Test Manually: Quick human validation.   - Auto-Generate & Run Tests: Agents + Playwright/Selenium.   - Code/Review/Deploy: Human-in-loop for guardrails.  This flow boosts productivity 3x for teams—agents handle boilerplate/testing, you focus on architecture. Engineering teams love it: Less burnout, more shippable features. Bonus: Cost Savings Cut engineering hours by 40-60% (automated tests replace manual toil), reduce rework, and scale without headcount bloat. #AgenticCoding #SoftwareEngineering #AITesting #Playwright #Selenium #Automation

TDD vs SDD for Agentic Development Since last week, I stopped designing specs for implementation (Spec-Driven Development) and switched to working with agents using Test-Driven Development. I used to think it was efficient to design a spec, then polish it several times with different agents, then make a checklist from it, then kick off iterative implementation, then run through the checklist, fix "gaps" and missed features and nuances. Somewhere at the end of the spec there'd be a section saying "cover everything with proper tests." It worked, but not great. LLMs have way too much self-esteem and self-confidence. So their tests are always good (in their opinion) and there's always enough of them (in their opinion). In reality, the tests are always crap (and not just with agents). They're almost always unit tests, not functional, and definitely not end-to-end. Even the functional ones are mocked to hell, so they effectively turn back into unit tests anyway. Without working e2e tests, an LLM can spend ages convincing you that everything is done and working, here's your pass rate 375/375, and then you deploy it on a separate server and it can't even handle the basic scenario. And you're like "what da f**?" And it responds "You're absolutely right, what da f**k." I got sick of it, so I changed my approach. Instead of creating a dev spec, I ask it to put together a proposal for the feature (which is something between a product PRD and a technical spec). Then I ask it to design functional and e2e tests. They must fail, because there's no implementation yet. But we already know how we're going to verify it. And then the magic begins. Seeing the PRD and failing tests, the agent starts iteratively implementing the functionality. It implements part of the feature, runs the tests. And out of 45 tests, 9 turn green. Then another iteration. Then another. And finally, all 45 tests pass without errors. I review the e2e tests myself, and that's the only thing you need to actually review in this case, and I understand what these tests should be about because they test a specific feature in real scenarios on a live setup. And if they pass, then everything's fine. On the downside — sometimes you need a separate task to get that test setup in place. For example, wrapping components into Docker images. But you immediately kill several birds with one stone: feedback loop for the agent, real-world test scenarios, and a nearly ready CI/CD that's easy to then configure as GitLab/GitHub workers and run on every new MR. So yeah, today I'm in the TDD camp (doesn't mean tomorrow I won't find something even more effective). But for now, this is it. And spec-driven development, imho, is less suited for agents, because any AI development should start with "evals", and "evals" in development are precisely those feature tests.

After more than a year of agentic coding — delivering 3 real projects with the latest technologies — I wanted to share my experience, and the gaps I still see models not addressing. I come from a software background. In the early days of C and Java, we spent a lot of time learning best practices from our seniors: design patterns, code quality, exception and error handling, reusability, configuration management, and so on. Now, with models like Claude, Codex, Gemini, and tools and frameworks built on top of them, I'm surprised that none of them really address the core pains of agentic development. Some examples I keep running into: 🔸 **Fallbacks everywhere:** Models build fast and handle edge cases — but through fallbacks, not proper design. They rarely stop and think about the real issue or the right path. No matter how much you instruct them through .md files, they keep doing it. 🔸 **Large inline code and duplication:** We used to flag any duplicated block over a certain size and refactor it into something reusable. Models can do this too, but only while the context is still clean. After that, they drift into inline fixes and duplication. 🔸 **Exception muting:** If there's a problem, silence it. Generic exception handling, issues hidden from users, no proper exception strategy. 🔸 **Happy-path testing only:** Reports look green, the release looks ready — then real issues surface during user testing. And the list goes on. What surprises me most is that when I enforce these principles or audit the code, the model can handle them and fix the issues — but only after I point it in the right direction. It makes me wonder: what data were these models trained on? Have we lost these best practices over time? Are they no longer common? And how are benchmarks rating models so highly when these fundamentals are missing? To work around this, I've had to: ✅ **Never leave a coding session unattended.** I review and scan every change before committing, applying principles from *bad code smells* (a 20+ year old book that still holds up). ✅ **Audit the code after each major release.** Non-negotiable. ✅ **Customize frameworks** like Superpowers and GSD with this knowledge. ✅ **Testing, testing, testing** with every major release. Agentic coding is only as good as the engineer using it. It can be a disaster if you expect it to work by itself. Unless these principles are applied, don't expect a workable product. It has helped me enormously in learning new technologies — things that would have taken me a year to pick up at this stage of my career. But when I read the reports about agentic coding "replacing humans," I really wonder. If an engineer doesn't know how to apply these principles and properly design and audit code — then yes, they will be replaced. My view: the future of humans in software development relies on very old skills, not new technologies. Our role as seniors is to pass that knowledge on.

I've done at least 5 speaking engagements now on vibe coding or using AI to develop software to different audiences. Not an expert, I don't believe in experts when we're moving at this pace, be wary of them. But I don't like the term 'vibe coding' for what I do. To some it applies perfectly. You are iterating on your ideas with a coding agent (e.g. Claude Code, v0, Replit, Bolt, Lovable, etc). It feels amazing, especially to somebody who has never been able to create 'apps'. To the uninitiated who has never been on the business end of a sprint team's QA cycle or a security review, that's an actual application. The distinction between vibe coder and this Builder role everybody is talking about (the AI SDLC practitioner) is just that... real software development. Like an orchestra conductor who has spent a career dabbling in all of the instruments. Turns out 25+ years of development on desktop, mobile, web, touchscreen, Linux nerdery, running servers, etc comes in handy. 2 x Claude Max 20x accounts, CI/CD environments, self-hosted Github Actions runners, 4-6 Claude Code instances running in separate worktrees, frequent and exhaustive Project Codeguard-powered security reviews of the entire monorepo, accessibility, encryption and privacy, DR, near perfect E2E and unit testing coverage. That's the AI SDLC, an entirely different skill set in my experience. Until AI completes the iceberg underneath the water without us guiding it there surgically, protecting vibe coders and their end-users, it's not reality. That vibe application you launched doesn't have a real back-end (it's superficial at best). Your customer data or an entire feature set will be gone in a minute with one wrong LLM turn. It's lacking the discipline and rigour. Developing in the AI SDLC means creating tons of things to keep the LLM accountable at all times to reach real productivity. It's one half of the reason that the 'SaaS is dead' narrative is (mostly) hype. The other half being non-technical... distribution, customer support, etc, where the real grind is today. Yes, you can create a CRM in an afternoon of Claude Code (which I have). It will give you this amazing feeling of accomplishment until you zoom out and see the underwater portion of that iceberg. 500k lines of vibe code later and orgs will have a lot of failed experiments in this area, hopefully not at the expense of customer data. With laser focus on security, privacy from day one in one of my personal projects, I still ended up with a new batch of 20 MED-CRITICAL security findings in a fresh review today (which I promptly addressed). Many things I've never even heard of. That's with pointing the agent to the problem space and carefully working with it. That's with knowing (roughly) what you're doing when it comes to the SDLC. Now imagine somebody without experience doing it.

Most AI coding tools help you write code faster. But shipping software is not just writing code. It is turning an idea into a production-ready solution that is tested, stable, scalable, and verifiable. Whether you are an entrepreneur shaping a new product idea, a developer building on an existing codebase, or a DevOps engineer wiring up infrastructure, the journey from concept to production touches far more than code. Discovery, architecture, specs, planning, execution, review, deployment. Most tools accelerate one of those steps. None of them connect the full chain. So I built Arness. Yes, I dropped the H on purpose 😊. Today I'm open-sourcing it. Arness is a plugin marketplace for Claude Code by Anthropic that covers the entire software project lifecycle. Three plugins, each independently installable, but together they form a single pipeline from first idea to production: Spark takes a raw idea through product discovery, persona generation, competitive research, brand naming (with real WHOIS and trademark checks), architecture evaluation, full use case specs, and clickable prototypes you can present to a customer or stakeholder. Every artifact feeds directly into the coding phase. Code is a development pipeline that scales process to scope. A quick bug fix gets minimal ceremony. A cross-cutting feature gets full spec, plan, multi-agent execution, and review with parallel execution across Git worktrees. It works on new and existing codebases, learning your patterns automatically. Infra handles containerisation, IaC, CI/CD, environment promotion, secrets, and monitoring with the same structured change management as the dev pipeline. It knows you. Arness captures your experience, skills, and preferences on first use and carries them across every session. Your idea, your codebase patterns, your target audience, your skill set. It all persists without you having to repeat yourself. 88 skills and 46 specialist agents behind the scenes, but you only need three entry points: /arn-brainstorming, /arn-planning, and /arn-infra-wizard. From there, each plugin drives itself. Integrates with GitHub, Jira, Bitbucket, and optionally Figma and Canva. Tested with about two dozen colleagues over the past several months. Their feedback shaped every rough edge. Their enthusiasm gave me the confidence to share it more widely. To all the fellow engineers, entrepreneurs, and builders I have met during my career: this is for you. MIT license, fully open source. Arness was built with Arness. All 134 components went through its own pipeline. https://lnkd.in/eVd6whVS If you try it, I would genuinely love your feedback. And if it resonates, a star on GitHub goes a long way for an open-source project just getting started. #OpenSource #AI #AgenticAI #DevTools #SoftwareEngineering

Mastering Claude Code Goes Beyond Basic Prompts Claude Code is emerging as a powerful agentic coding tool. It excels not only at generating code but also at reading existing codebases, modifying files, executing terminal commands, and integrating with existing developer workflows across terminals, IDEs, desktops, and browsers. Often, users can achieve desired outcomes by simply describing their needs, allowing Claude Code to handle complex tasks. However, utilizing Claude Code out-of-the-box only reveals a fraction of its potential. To unlock its full capabilities, developers must understand its surrounding ecosystem, which includes custom skills, sub-agents, hooks, integrations, project-specific instructions, and reusable workflow patterns. These elements transform Claude Code from a simple assistant into a robust development system, driving significant interest in community-developed repositories and guides. The focus is shifting from mere prompts to better methods for structuring agent behavior, reducing debugging efforts, enhancing consistency, and improving effectiveness on larger projects. Here are key GitHub repositories that can aid developers in enhancing their Claude Code proficiency. The `everything-claude-code` repository serves as an excellent starting point for transforming Claude Code into a structured and advanced agentic setup. This project emphasizes a performance-oriented system for AI agent harnesses, going beyond simple prompts or configurations. It incorporates features such as agents, skills, hooks, rules, Model Context Protocol (MCP) configurations, memory optimization techniques, security scanning capabilities, and research-centric workflows. Developed with over 10 months of daily real-world application and recognized with an Anthropic x Forum Ventures hackathon award, this repository is considered a sophisticated reference for advanced Claude Code workflows. The `system-prompts-and-models-of-ai-tools` repository offers valuable insights into the broader landscape of AI tooling surrounding Claude Code, rather than focusing solely on the tool itself. This project compiles exposed system prompts, tool definitions, and model-specific details from various AI products, including Claude Code, Cursor, Devin, Replit, Windsurf, Lovable, and Perplexity. It proves particularly beneficial for those interested in prompt design, agent behavior analysis, and understanding the underlying structures of different AI coding and productivity tools, facilitating a deeper comprehension beyond the isolated use of a single product. The `gstack` repository exemplifies how Claude Code can function as a coordinated AI team instead of an individual assistant. This project showcases Garry Tan’s Claude Code configuration, demonstrating advanced implementation techniques. Full article and source link in the comments 👇 Published through a fully automated AI news system from TMC AI

My biggest aha moment working with coding agents some months ago was realizing the importance of meta-thinking — or what some call meta-agentics. As an engineer, I believe this is one of the most important concepts if you want to truly scale and compound your agentic workflows. Most people I see work with coding agents in two ways: They either go back and forth iterating, vibe-coding and staying in the loop too much. Or they use some opinionated, spec-driven framework to create structured spec files and handing these specs over to an agent. Both approaches are ok. But I think the impact in both of them is limited. In both cases, the engineer is still in the loop working directly on the development of a specific app. The artifacts — prompts, skills, sub-agent delegation, multi-agent orchestration workflows — are often created from scratch for that one application. I think engineers should be focusing more on templatizing every unit of the agentic workflow: - prompts - skills - specs - sub-agent delegation - orchestration workflows The goal is not just to build an application with these components, but to build a reusable system that can build systems (applications). The different units of that system can then generate, adapt, and recombine workflows dynamically across one or many applications instead of forcing teams to recreate the same artifacts every time. Imagine i.e: Input → a feature requirement System → a prompt template (meta-layer) Output → a new spec this can be extended to: Input → a skill requirement System → a skill template (meta-layer) Output → a new skill all the way to: Input → a team of agents requirement System → teams of agents template (meta-layer) Output → a new team of agents This is also why I’m skeptical when people become overly obsessed with individual features like agent skills without looking at the different units of the system holistically: - Agentic prompts for workflow orchestration - Skills for agent capabilities - Sub-agents for parallelism - Teams of agents for multi-agent orchestration To me, this is the essence of meta-thinking: Templatize these composable units of your agentic workflows so they can be reused dynamically and create news artifacts based on the requirements of the application at hand. That is where compounding starts. This principle is so powerful — but it also comes with responsibility. Teams need ownership over these templates or meta-layers of units. They need to maintain them, evaluate them, and continuously improve them as part of their agentic engineering pipelines.

Vibe coding isn’t a fad anymore – it’s quickly becoming the default way we explore, prototype, and ship software with AI as a first-class collaborator. Naveen has been building a product that can tell you how risky your career is and how much time you have to upgrade yourself. Besides analyzing risk, this will help diagnose CV and LinkedIn profile to develop a new career narrative. That’s exciting. But yes, vibe coding comes with risks that leaders can’t ignore. So, what is vibe coding! Vibe coding is building software primarily through natural-language prompts, letting AI agents generate, refactor, and stitch together most of the code while humans steer by intent and feedback. Instead of wrestling with syntax, we describe the “vibe” of the feature and iterate conversationally until it works. This shift impacts not only developers, but also PMs, analysts, and non‑technical founders who are now shipping scripts, micro‑apps, and internal tools. Popular vibe coding tools: Cursor – AI‑native IDE that deeply understands your codebase, great for power developers who want speed without losing control. Mature with large user base (Fortune 500+ support). Windsurf – more autonomous multi‑step execution for large changes across many files, ideal for advanced coders and big projects. Claude Code – an agentic coding companion that reads your repo, plans tasks, edits files, and runs commands from natural language. Google AI Studio - Generate web apps (React/Next.js/Angular) from prompts, add DB/auth (Firebase built-in), secure API keys, collaborative, deployable. Free to use; supports production apps. Open AI Codex: Multi-agent workflows, background tasks, automated refactors, code review integration v0 by Vercel – turns UI prompts into production‑ready React/Next.js front‑ends you can export and harden in your own stack. Replit/Lovable – browser‑based environment where you can prompt, build, and deploy full‑stack apps from a single collaborative workspace. Why vibe coding is powerful Speed: Idea → prototype in hours instead of weeks, especially for CRUD apps and internal tools. Accessibility: Non‑coders can participate directly in building and iterating on software. Leverage: Senior engineers focus on architecture, reviews, and hard problems while agents handle boilerplate. The downside we must manage: Shadow apps: Unreviewed AI‑built tools creeping into production without security or compliance. Fragility: Systems that “work in the demo” but are hard to debug, extend, and reliably operate. Skills erosion: Over‑reliance on vibes instead of fundamentals in testing, observability, and design. Vibe coding isn’t going away. The organisations that win won’t be those that vibe the hardest, but those that pair this new creative superpower with strong engineering standards, governance, and a culture of responsible experimentation. Preeth Sumeet Piyush Agilemania Vikram Ashwinee #vibecoding #AI #AIDevelopment #AISM #AIPO

𝗔𝗿𝗲 𝘆𝗼𝘂 𝘀𝘁𝗶𝗹𝗹 𝘁𝗿𝗲𝗮𝘁𝗶𝗻𝗴 𝘆𝗼𝘂𝗿 𝗢𝗽𝗲𝗻 𝗖𝗼𝗱𝗲𝘅 𝗔𝗜 𝗰𝗼𝗱𝗶𝗻𝗴 𝗮𝗴𝗲𝗻𝘁𝘀 𝗹𝗶𝗸𝗲 𝗷𝘂𝗻𝗶𝗼𝗿 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀 𝗼𝗻 𝘁𝗵𝗲𝗶𝗿 𝗳𝗶𝗿𝘀𝘁 𝗱𝗮𝘆? 𝗜𝘁’𝘀 𝘁𝗶𝗺𝗲 𝘁𝗼 𝘂𝗽𝗴𝗿𝗮𝗱𝗲 𝘁𝗼 𝗔𝗴𝗲𝗻𝘁𝗶𝗰 𝗗𝗿𝗶𝘃𝗲𝗻 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗺𝗲𝗻𝘁 (𝗔𝗗𝗗). If you aren't using an `AGENTS.md` file in your repositories yet, you are missing out on a massive productivity boost. Already adopted by over 60,000 open-source projects, `AGENTS.md` acts as a "README for AI agents". While a standard `README.md` is for humans, `AGENTS.md` gives AI tools (like GitHub Copilot, Codex, Cursor, and Gemini) the exact context they need to succeed: your build steps, architectural rules, and strict coding conventions. Here is why this simple markdown file is a game-changer: 𝗣𝗮𝘀𝘀𝗶𝘃𝗲 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 𝗕𝗲𝗮𝘁𝘀 𝗔𝗰𝘁𝗶𝘃𝗲 𝗥𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹: A recent Vercel study found that giving agents passive access to a compressed documentation index inside an `AGENTS.md` file resulted in a **100% pass rate** across Build, Lint, and Test tasks. When relying on agents to actively "decide" to look up documentation using "skills", the pass rate plummeted to just 53%. 𝗦𝗸𝗶𝗽 𝘁𝗵𝗲 𝗥𝗲𝗽𝗲𝘁𝗶𝘁𝗶𝗼𝗻: Instead of repeating "use TypeScript strict mode" or reminding the AI to use your specific testing frameworks in every single chat prompt, you define the "law" once in your project root. 𝗧𝗵𝗲 𝗠𝘂𝗹𝘁𝗶-𝗔𝗴𝗲𝗻𝘁 𝗪𝗼𝗿𝗸𝗳𝗹𝗼𝘄: With ADD, developers are moving "up the stack." We are no longer just writing boilerplate; we are orchestrating pipelines where different AI personas (like a Product Manager, Full-Stack Engineer, and QA Engineer) draft, implement, and cross-review each other's code before a human even looks at it.  𝗧𝗼𝗽 𝟯 𝗕𝗲𝘀𝘁 𝗣𝗿𝗮𝗰𝘁𝗶𝗰𝗲𝘀 𝗳𝗼𝗿 𝘆𝗼𝘂𝗿 `𝗔𝗚𝗘𝗡𝗧𝗦.𝗺𝗱`: 𝗞𝗲𝗲𝗽 𝘁𝗵𝗲 𝗵𝗶𝗲𝗿𝗮𝗿𝗰𝗵𝘆 𝗳𝗹𝗮𝘁:Put a single, concise `AGENTS.md` file in your repo root for high-level rules, and point to a `.agents/skills/` folder for domain-specific instructions. 𝗦𝗲𝘁 𝘀𝘁𝗿𝗶𝗰𝘁 𝗯𝗼𝘂𝗻𝗱𝗮𝗿𝗶𝗲𝘀: Tell your agent what it should *always* do, what it must *ask first*, and what it should *never* do (like deleting failing tests or modifying database schemas without permission). 𝗨𝘀𝗲 𝗳𝗶𝗹𝗲-𝘀𝗰𝗼𝗽𝗲𝗱 𝗰𝗼𝗺𝗺𝗮𝗻𝗱𝘀: Instruct your agent to run linters or type-checkers on a per-file basis rather than running project-wide builds. This drastically speeds up feedback loops and saves tokens. Stop paying for your AI to blindly rediscover your codebase's architecture on every single prompt. Drop an `AGENTS.md` in your repo today and watch the output quality skyrocket. Have you experimented with `AGENTS.md` or AI Skills in your workflows yet? Let me know your experience in the comments! #AI #SoftwareEngineering #DeveloperTools #AGENTSmd #AgenticDrivenDevelopment #Productivity #GitHub #WebDevelopment #Claude #OpenAI #Codex #Cursor #Angular #React #NextJS #ExpressJS #SpringBoot #NestJS

Top AI Coding Agents in 2025 - https://lnkd.in/gccR3gKQ Transforming Software Development with AI Coding Agents in 2025 AI-powered coding agents are revolutionizing software development, enhancing productivity and simplifying workflows. Here are some of the top AI coding agents available: Devin AI Efficient Project Management: Devin AI is great for handling complex tasks with its ability to run multiple processes at once. This makes it ideal for large projects that need strong performance. GitHub Copilot Smart Code Assistance: GitHub Copilot helps developers by suggesting code and completing it automatically. This tool integrates into development environments, making coding faster and easier. Magic Patterns UI Component Creation: Magic Patterns speeds up development by offering a library of reusable UI components. This reduces time spent on repetitive tasks, allowing developers to tackle more complex issues. Windsurf Code Quality Insights: Windsurf automates code analysis, providing valuable insights into code quality and potential problems, helping developers maintain high standards and catch bugs early. Uizard AI Rapid Prototyping: Uizard AI allows designers to quickly turn ideas into interactive prototypes, speeding up the design process and enhancing user testing for better user experiences. Replit Agent Streamlined SME Workflows: Replit Agent is designed for small and medium enterprises, automating coding tasks and integrating with various development tools to simplify the coding process. Galileo AI Mobile UI Development: Galileo AI helps developers create user-friendly mobile interfaces, ensuring apps work well on different devices and screen sizes. Warp Task Automation: Warp uses a multi-agent approach to automate coding tasks, improving efficiency and helping developers manage complex projects more effectively. Lovable Dev Design to Development: Lovable Dev converts Figma designs into functional applications, making collaboration between designers and developers seamless. Bolt New User-Friendly Interface: Bolt New is easy to use and deploy, supporting rapid prototyping and integration with various development environments for quick iterations. V0 Dev Framework Flexibility: V0 Dev supports multiple frontend frameworks, giving developers the choice to use the best tools for their projects. Cursor Code Management: Cursor helps developers keep their code organized with tools for version control, code reviews, and collaboration, promoting best practices. Conclusion The AI coding agents of 2025 provide a wide range of tools that enhance efficiency and support high-quality application development. As AI technology advances, we can expect even more innovative features that will further improve the development process. Follow us on Twitter, join our Telegram Channel, and participate in our LinkedIn Group. Don’t forget to check out our 75k+ ML SubReddit. Embrace AI to Stay Competitive Discover how AI can