Beyond Chat: Building an AI Agent That Understands Your Entire Development Workflow

Series: Agentic Engineering – Practical AI Workflows for Modern Software Teams (Part 1)

Introduction

Artificial Intelligence has quickly become an integral part of a software engineer's toolkit.

We ask ChatGPT to explain unfamiliar code, use GitHub Copilot to autocomplete functions, and occasionally paste a pull request into an LLM for feedback. These tools undoubtedly improve productivity, but they still depend heavily on one thing: us.

We gather the pull request.
We search for the Jira story.
We copy the acceptance criteria.
We summarize the business requirements.
We explain the repository structure.
Only then do we ask the AI to help.

That isn't automation.

It's simply moving manual work into a chat window.

Over the past few months, I've become increasingly interested in a different approach—building AI agents that can understand engineering workflows, gather their own context, interact with developer tools, and complete meaningful tasks with minimal human intervention.

This article marks the beginning of a new series called Agentic Engineering, where I'll share practical implementations of AI-powered workflows that automate repetitive engineering tasks across the software development lifecycle.

The Problem

Let's look at a typical pull request review.

A reviewer usually needs to:

• Open the Pull Request
• Read the code changes
• Find the corresponding Jira story
• Understand the business requirements
• Read the acceptance criteria
• Compare implementation against requirements
• Check coding standards
• Leave review comments

Depending on the complexity of the change, simply gathering context can consume 15–30 minutes before any real technical review even begins.

As repositories grow larger and development teams become more distributed, this overhead becomes increasingly expensive.

What If the Agent Did the Context Gathering?

Instead of asking an AI:

Review this pull request.

I wanted to build an agent that already knows:

• Which repository to inspect
• Which Pull Request to analyze
• Which Jira story is associated with the PR
• What are the acceptance criteria
• What files changed
• How to generate a structured review

The objective isn't to replace software engineers.

It's to eliminate repetitive work so reviewers can focus on architecture, business logic, security, and edge cases.

My First Productivity Agent

To explore this idea, I built a simple command-line agent that orchestrates multiple developer tools into a single workflow.

The implementation currently uses:

• GitHub CLI (gh)
• GitHub Copilot CLI
• Jira REST API

Rather than treating these as independent tools, the agent combines them into a single engineering workflow.

High-Level Architecture

                Developer

                    │

                    ▼

            AI Productivity Agent

        ┌───────────┼────────────┐
        │           │            │
        ▼           ▼            ▼

 GitHub CLI     Jira REST API   Copilot CLI

        │           │            │
        └───────────┼────────────┘
                    │

                    ▼

         Structured Review Report

The agent collects information from GitHub and Jira, builds the necessary context, and asks Copilot CLI to perform a structured review.

Instead of manually assembling prompts, the engineer simply invokes the workflow.

Current Commands

The current version exposes three commands.

List Pull Requests

agent --list

Displays pull requests that are available for review.

Review All Pull Requests

agent --review-all

Reviews every eligible pull request automatically.

This is useful before a release or during periods when multiple PRs are waiting for review.

Review a Single Pull Request

agent review-pr \
    --repo engineering-service \
    --pr 248 \
    --jira ENG-542

The agent:

• Retrieves PR details from GitHub
• Retrieves the Jira story
• Reads acceptance criteria
• Collects changed files
• Sends the complete context to Copilot CLI
• Produces a structured review

The engineer no longer needs to gather all of this information manually.

Why GitHub CLI?

GitHub CLI already solves authentication and repository access elegantly.

Instead of writing custom integrations for every GitHub API endpoint, I can retrieve:

• Pull Request metadata
• Changed files
• Commit history
• Repository information

with simple CLI commands.

This keeps the implementation lightweight while still providing everything the agent needs.

Why Jira?

Git tells us what changed.

Jira tells us why it changed.

Without the Jira story, an AI review can evaluate syntax, formatting, and code quality—but it cannot determine whether the implementation actually satisfies the original business requirements.

Retrieving the Jira story and its acceptance criteria makes the review much more meaningful.

Why Copilot CLI?

Copilot CLI acts as the reasoning engine.

Instead of manually crafting prompts, the agent prepares all of the required context and delegates the analysis to Copilot.

The result is a review that's aware of:

• Code changes
• Business requirements
• Acceptance criteria
• Repository context

rather than just isolated code snippets.

Why I Consider This an Agent

Today, many applications wrap an LLM and call it an "AI Agent."

I think the definition should be a little stricter.

A useful engineering agent should be able to:

• Gather information independently
• Invoke external tools
• Combine information from multiple systems
• Make workflow decisions
• Produce meaningful outputs without requiring constant human guidance

This project isn't just sending prompts to an LLM.

It's orchestrating GitHub, Jira, and Copilot into a workflow that removes repetitive engineering work.

That, to me, is where agents become genuinely useful.

Looking Ahead

Pull request reviews are only the beginning.

Over the next several articles in this series, we'll continue building practical engineering agents to automate other parts of the software development lifecycle, including:

• Automated release notes
• Jira Story → First Pull Request workflow
• AI-powered developer onboarding
• Automated documentation generation
• AI-assisted testing
• Incident response assistants
• Engineering knowledge agents

The goal isn't to replace engineers.

It's to eliminate repetitive work so engineers can spend more time solving meaningful problems.

If you're building similar workflows—or have ideas for engineering tasks that could be automated—I'd love to hear about them in the comments.

About the Author

Hi, I'm Nachiket Joshi.

I'm a software engineer, AI researcher, published author, and international keynote speaker passionate about building intelligent software systems.

Through this series, I share practical engineering solutions, architecture patterns, and lessons learned while building AI-powered engineering workflows.

Outside of engineering, I enjoy building side projects, exploring emerging technologies, and unwinding with strategy and simulation games.