Introduction
Artificial intelligence has moved far beyond the chatbot window. What started as a convenient way to ask questions and generate boilerplate code has evolved into something fundamentally different: agentic AI—systems that don’t just respond to prompts but actively participate in multi-step workflows, make decisions within defined guardrails, and collaborate with human engineers in real time. For software engineers, this shift is not a distant future; it is happening right now, and it is transforming how we plan, build, test, and ship software.
As a software engineer at Ingenuity, I wear many hats—developer, occasional customer support, sometimes even a makeshift project manager. The core challenge has always been the same: delivering quality output at speed while helping stakeholders and teammates wherever I can. When I first started using AI, it was little more than a smarter search engine. Today, it is an integral collaborator in nearly every phase of my development workflow. This blog post explores that journey and, more importantly, lays out a practical framework for how agentic AI is reshaping the way modern software gets built.
1. The Evolution: From Asking Questions to Orchestrating Agents
In April 2023, my interaction with AI looked like this: I would paste a slide outline into ChatGPT and ask it to polish the wording for a monthly townhall presentation. The AI was a writing assistant—useful, but passive. I asked; it answered. The cognitive load of deciding what to ask, how to frame the prompt, and how to integrate the result back into my work remained entirely on me.
Fast-forward to 2026, and the relationship has inverted. I no longer ask AI isolated questions. Instead, I spawn AI agents that understand the full context of a codebase, execute multi-step plans, write and run tests, review each other’s output, and even push code to version control—all within a single, orchestrated workflow. The shift from “AI as a question-answering tool” to “AI as an autonomous collaborator” is what the industry calls agentic AI, and it represents the single largest productivity leap I have experienced in my career.
2. What Is Agentic AI?
Agentic AI refers to AI systems that can autonomously pursue goals over multiple steps, use tools, make intermediate decisions, and adapt their approach based on results—all while operating within human-defined boundaries. Unlike traditional chatbot interactions (prompt in, response out), an agentic system can:
- Break a high-level objective into sub-tasks and execute them sequentially or in parallel.
- Read, write, and modify files across an entire project.
- Run shell commands—build tools, linters, test suites, deployment scripts.
- Search the web, consult documentation, and fetch context from external services (Jira, GitHub, Slack, Sentry).
- Spawn sub-agents with specialized roles (security reviewer, performance analyst, test writer) and synthesize their findings.
- Self-correct when a step fails, diagnose errors, and retry with a different strategy.
The key distinction is autonomy within guardrails. An agentic system does not need a human to hand-hold every step, but it does operate under constraints—permission boundaries, review checkpoints, and safety rails—that keep it aligned with the engineer’s intent.
3. The Tooling Ecosystem
Agentic AI does not exist in a vacuum. It requires an ecosystem of tools and integrations to be effective. Here is a snapshot of the stack I use daily:
Development Environment
VS Code serves as the primary IDE, augmented with AI-native extensions. Claude Code (Anthropic’s CLI) is the backbone of my agentic workflow—it lives in the terminal, has full filesystem access, and can orchestrate sub-agents for parallel work. Cursor provides an alternative AI-first editor for rapid prototyping. GitHub Copilot offers inline code suggestions.
AI Models
Claude (Anthropic) handles the heavy lifting—planning, implementation, and review. ChatGPT (OpenAI) and Gemini (Google) serve as cross-reference tools for research and validation. Different models have different strengths; using multiple prevents tunnel vision.
MCP Servers and Integrations
Model Context Protocol (MCP) servers are the connective tissue of agentic workflows. They allow AI agents to interact with external services—GitHub for PRs and code reviews, Jira for ticket management, Slack for notifications, SonarCloud for code quality metrics, and Sentry for error tracking. These integrations transform the AI from a code-generation tool into a full-stack development partner.
4. The Agentic Software Development Workflow
The real power of agentic AI emerges when you map it onto the full software development lifecycle. Here is how AI now fits into each phase:
Ideation and Pre-Planning
Before writing a single line of code, I describe the feature or bug to an AI agent. The agent researches the codebase, identifies relevant files, and surfaces architectural considerations I might have missed. This replaces hours of manual code archaeology.
Planning
A dedicated planner agent takes the ideation output and produces a structured implementation plan—broken into phases, with dependencies mapped, risks identified, and testing strategies defined. For complex features, a “deep plan” step sends parallel research agents to gather documentation, best practices, and framework-specific guidance before the plan is finalized.
Implementation
This is where the 10x multiplier becomes real. An implementation agent works through the plan step by step, writing code, running tests, and fixing build errors. A feature that was estimated at five months of manual development was completed in just two days using this workflow. The agent handled the bulk of the implementation while I provided guidance, reviewed critical decisions, and course-corrected when the agent veered off track.
Review and Verification
One of my most effective patterns is using AI to review AI. After an implementation agent completes its work, I spawn a separate reviewer agent—sometimes multiple, each with a different focus (security, performance, code style, architectural consistency). This multi-perspective review catches issues that a single-pass human review might miss. That said, human review remains irreplaceable for judgment calls, business logic validation, and the kind of contextual understanding that no model fully captures yet.
Testing
Test-driven development becomes dramatically more accessible with agentic AI. The agent writes unit tests, integration tests, and even end-to-end tests, runs them, analyzes failures, and iterates until coverage targets are met. In a recent PR, I used agents to raise test coverage from under 60% to above 80% across 23 files—work that would have taken days of manual test writing.
Debugging
When something breaks, the AI agent can read error logs, trace stack frames, inspect database state, and propose fixes—often faster than I could manually. The agent’s ability to hold the entire codebase in context while reasoning about an error is a genuine superpower.
Deployment and Monitoring
Agents can push code, open pull requests, notify the team on Slack, and monitor CI/CD pipelines. The self-healing pattern—where an agent detects a failing build, diagnoses the issue, applies a fix, and re-runs the pipeline—is one of the most powerful applications of agentic AI in production workflows.
5. When AI Excels—and When It Struggles
Where AI Shines
AI is exceptionally good at greenfield implementation—building new features from scratch where there are no existing patterns to conflict with. It excels at repetitive, well-defined tasks: writing serializers, creating CRUD endpoints, generating test fixtures, formatting documents, and scaffolding boilerplate. It is also remarkably effective at cross-domain support. I once used AI to navigate Microsoft Azure’s deployment infrastructure for a client project (Aboitiz Streetlight API), a domain I had no prior experience in. The AI bridged the knowledge gap in hours rather than weeks.
Where AI Struggles
The most consistent failure mode I observe is with modifications to existing, interconnected code. When an AI agent needs to update a feature that touches multiple files, existing tests, and established patterns, it often introduces regressions or misunderstands the implicit contracts between components. The agent might correctly implement the change in isolation but break something downstream because it did not fully grasp the side effects. This is where human guidance becomes critical—you need to “assist your assistant.”
Another common pitfall is what I call “micromanaging the AI.” If you over-specify every step, you lose the productivity benefit. If you under-specify, the AI may take a wrong turn and waste tokens (and your time) on an incorrect approach. Finding the right level of abstraction in your instructions is a skill that takes practice.
6. Guardrails: Judgment and Boundaries
Agentic AI without guardrails is a liability. The more autonomy you grant an AI system, the more important it becomes to define clear boundaries. Here are the guardrails I enforce:
- Security and Data Privacy: AI agents must never handle raw secrets, credentials, or personally identifiable information without explicit human approval. Sensitive operations require manual confirmation.
- Autonomous Actions: Destructive operations—force-pushing, deleting branches, modifying production databases—are never allowed without human review, no matter how confident the agent is.
- Permission Controls: Tool permissions are configured explicitly. The agent can read files freely but must ask before writing. It can run tests but not deploy to production. These boundaries are enforced at the tooling level, not just by prompting.
- Cross-Agent Review: I routinely spawn a second AI agent to review the output of the first. This “AI reviewing AI” pattern catches a surprising number of issues—incorrect logic, missed edge cases, security vulnerabilities—that the implementing agent missed.
- Human-in-the-Loop: Ultimately, human judgment remains the final checkpoint. AI can suggest, implement, and even deploy—but the engineer must validate that the output aligns with business intent, user experience standards, and the broader system architecture.
7. Practical Guidelines for Using AI to Build with AI
If you are an engineer looking to adopt agentic AI into your workflow, here are the lessons I have learned through months of daily use:
- Write effective prompts. The quality of your output is directly proportional to the quality of your input. Be specific about what you want, provide context, and define the constraints. Every engineer eventually develops a personal prompting style—experiment until you find yours.
- Manage context aggressively. AI agents have finite context windows. Clear the conversation when it gets too long. Start new sessions for new tasks. Load only the relevant files and documentation at the start of a session.
- Leverage MCP servers and tool integrations. The more tools your agent can access—version control, issue trackers, CI/CD pipelines, monitoring dashboards—the more autonomous and effective it becomes.
- Create reusable skills and templates. Use the AI itself to create skills (reusable prompt templates) tailored to your specific workflow. A well-crafted skill for “review this PR” or “resolve SonarCloud issues” saves enormous time across dozens of invocations.
- Start with low-risk tasks. Build trust incrementally. Start with documentation, test generation, or code formatting before graduating to feature implementation or debugging.
8. The Bigger Picture: What This Means for Software Engineering
Agentic AI does not replace software engineers. It amplifies them. The engineer’s role shifts from writing every line of code to orchestrating intelligent systems, making architectural decisions, validating business logic, and applying the kind of contextual judgment that AI cannot yet replicate. The engineers who thrive in this new paradigm will be those who learn to collaborate effectively with AI—treating it as a powerful but imperfect teammate that needs clear direction, regular review, and appropriate guardrails.
The productivity gains are real and significant. Tasks that once took weeks can be completed in days. Test coverage that was perpetually aspirational becomes achievable. Code reviews become multi-dimensional. Documentation stays current. But these gains come with responsibility: the engineer must remain the accountable decision-maker, the quality gatekeeper, and the ethical compass.
Conclusion
The transition from traditional AI assistance to agentic AI is not a gradual evolution—it is a paradigm shift. Software engineers who embrace this shift, learn its patterns, and respect its limitations will find themselves building better software, faster, with fewer defects. Those who dismiss it or adopt it without guardrails will struggle.
My advice is simple: utilize AI in your daily workflow. Always learn and test new things. But never become too reliant—always review, always challenge, and always remember that the AI is your assistant, not your replacement. The future belongs to engineers who know how to orchestrate intelligence, both human and artificial, toward building something meaningful.
