Welcome to Agentic Engineering — a series exploring how AI agents are transforming modern software engineering by automating repetitive workflows, orchestrating developer tools, and allowing engineers to focus on solving meaningful problems.
Why Another AI Series?
Over the past few years, Artificial Intelligence has rapidly become part of every software engineer's daily workflow.
We ask ChatGPT to explain unfamiliar code, rely on GitHub Copilot to autocomplete functions, generate unit tests with Claude, and summarize documentation using Gemini. These tools have fundamentally changed how we write software, and there's no doubt they have made us more productive.
But after months of using these tools, I noticed something interesting.
Most of my interactions still looked like this:
- Copy some code.
- Paste it into an LLM.
- Explain the repository.
- Provide business context.
- Ask a question.
- Copy the answer back into my IDE.
The AI wasn't doing my work.
I was doing all the work required to let the AI help me.
That realization led me to a much bigger question.
What if the AI could gather the context itself?
That question became the starting point for this series.
What Is Agentic Engineering?
Agentic Engineering is the practice of building intelligent software systems that can understand engineering workflows, gather their own context, interact with developer tools, make decisions, and execute meaningful tasks with minimal human intervention.
Instead of asking an AI to answer isolated questions, we give it an objective.
Rather than saying:
"Review this pull request."
We simply say:
"Review every open pull request assigned to Team Alpha."
The agent figures out the rest.
It discovers the pull requests, retrieves the code changes, understands the associated Jira stories, gathers the acceptance criteria, invokes the appropriate reasoning model, and produces a structured review.
The engineer no longer acts as the bridge between every tool.
The agent becomes that bridge.
Automation Has Been Around for Decades
At this point, it's fair to ask:
"Haven't we been automating software engineering for years?"
Absolutely.
Software engineering has always relied on automation.
Build servers compile our applications.
CI/CD pipelines deploy our services.
GitHub Actions execute workflows.
Scripts automate repetitive commands.
Infrastructure as Code provisions cloud environments.
So what makes AI agents different? The answer lies in how decisions are made. Traditional automation follows predefined instructions.
Agents pursue goals.
Understanding the Evolution of Automation
Let's look at how software engineering automation has evolved.
Scripts
Scripts are the simplest form of automation.
They execute a fixed sequence of commands.
Install dependencies
↓
Run tests
↓
Deploy application
Scripts are fast and predictable, but they only perform exactly what the developer programmed them to do.
There is no reasoning.
CI/CD Pipelines
CI/CD systems extend this idea.
They orchestrate multiple automation steps in response to predefined events.
Push Code
↓
Build
↓
Run Tests
↓
Deploy
Pipelines automate delivery extremely well. However, every possible path must still be explicitly defined.
The pipeline never asks:
"Should I perform another security scan?"
It simply follows instructions.
GitHub Actions
GitHub Actions introduced event-driven automation.
A pull request opens.
↓
A workflow starts.
↓
Tests execute.
↓
Comments are posted.
↓
Artifacts are published.
Although tremendously powerful, GitHub Actions remain deterministic. Every workflow is authored in advance.
If a new situation appears that wasn't anticipated, the workflow stops.
Robotic Process Automation (RPA)
RPA brought automation into business processes.
Bots imitate human interactions.
↓
They click buttons.
↓
Fill forms.
↓
Move files.
↓
Read spreadsheets.
This eliminated countless repetitive business tasks. Yet the automation still followed carefully scripted behavior.
If the screen changed unexpectedly, many bots simply failed.
LLM Assistants
Large Language Models changed the conversation.
Instead of executing predefined logic, they could reason about information.
Developers suddenly had assistants capable of:
- Explaining code
- Writing documentation
- Generating tests
- Refactoring functions
- Summarizing requirements
But there was still one limitation. The assistant depended entirely on the context supplied by the human.
It couldn't fetch missing information on its own.
Agentic Workflows
Agentic workflows represent the next step.
Instead of giving an AI isolated pieces of information, we give it access to tools and a goal.
For example:
Review every pull request merged into the release branch today.
An agent might decide to:
- Search GitHub for merged pull requests
- Retrieve each code diff
- Locate the associated Jira stories
- Read acceptance criteria
- Review implementation quality
- Identify testing gaps
- Generate release notes
- Publish a report
Notice something important. The engineer never described how to perform these steps. Only what needed to be accomplished.
That distinction is what makes agentic workflows fundamentally different from traditional automation.
So... What Exactly Is an AI Agent?
The term "AI Agent" has become incredibly popular. Unfortunately, it has also become incredibly vague.
Today, almost every application that calls an LLM markets itself as an AI agent.
Personally, I think we need a higher standard. An engineering agent should possess several characteristics.
1. It Has a Goal
Agents work toward objectives.
Not prompts.
2. It Can Gather Context
Agents retrieve information without requiring humans to manually assemble everything.
3. It Uses Tools
GitHub.
Jira.
Slack.
Docker.
Kubernetes.
Databases.
REST APIs.
The LLM is only one component.
4. It Makes Decisions
Rather than executing one fixed sequence, the agent chooses which tools to invoke and when.
5. It Produces Useful Outcomes
The goal isn't conversation.
The goal is to accomplish work.
The Philosophy Behind This Series
Every article in this series follows one simple principle. We're not building chatbots. We're building engineering teammates.
Each article explores a practical workflow that software engineers perform every day and asks a simple question:
Can an AI agent take care of the repetitive parts while leaving the engineering decisions to humans?
Some examples include:
- Reviewing pull requests
- Generating release notes
- Creating project scaffolding
- Automating developer onboarding
- Building engineering knowledge assistants
- Producing technical documentation
- Responding to production incidents
Each solution will be built using practical technologies that engineering teams already use every day, including GitHub, Jira, GitHub Copilot, REST APIs, Python, Docker, and cloud-native tooling.
No proprietary frameworks. No magical abstractions.
Just practical engineering.
Why This Matters
I don't believe AI will replace software engineers.
I do believe it will replace a significant amount of repetitive engineering work.
As software systems continue to grow in complexity, engineers spend an increasing amount of time gathering information rather than solving problems.
Agentic Engineering isn't about removing humans from the software development lifecycle.
It's about removing unnecessary friction.
When agents handle repetitive work, engineers have more time to focus on architecture, system design, reliability, security, performance, and innovation.
Those are the problems humans are exceptionally good at solving.
What's Next?
In the next article, we'll build our first engineering agent—one that understands pull request workflows by combining GitHub CLI, Jira, and GitHub Copilot into a single autonomous review process.
This isn't just another AI assistant.
It's the beginning of a new way of thinking about software engineering.
About the Author
|
Hi, I'm Nachiket Joshi. I'm a software engineer focused on AI systems, distributed platforms, and developer productivity workflows. I share practical implementations of AI-powered engineering systems. |
Top comments (0)