Please share to show your support

Animesh Kumar Sinha| Technical Architect | AI Systems | Agentic AI Evangelist

E-Journal Times Magazine

An intriguing case study that’s keeping me awake — a zero-employee organization is a real possibility.

This example is taken from Pot-Pie (now I re-branded myself as “Developer Assist”), a solution built using the Agentic AI framework. It enables the development of agents to support an organization across various SDLC phases.

In this article, I will explore how Developer Assist operates, why Agentic AI represents the future, and how combining the two could lead to a massive disruption — and for some, this is a huge opportunity — in the software development lifecycle. Agentic AI can redefine the Software Development Lifecycle by enabling autonomous, goal-driven agents to plan, code, test, and optimize with minimal human intervention.

Kindly check the diagram below

It illustrates how you can connect your codebase or GitHub repository from day one of your project. You can select the relevant module from Developer Assist based on your chosen agent.

The assistant will then start collaborating with you and begin building a knowledge graph — technically capturing your actions and decisions in a vector database. Later, this Graph is used as contextual memory to assist you throughout your SDLC journey

Inputs in the system

Codebase (Git): The place where all the source code is stored.

Knowledge Graph (Neo4j, Postgres): A smart database that understands relationships between different code elements.

Developer Assistance (The Helper Agents): These are specialized AI tools that help with specific tasks:

For example, I am working on a UI Modernization project, and I have to upgrade the Angular version of the front-end as part of a software upgrade. In the future, similar upgrades will be required.

I would select the UI Modernization Agent, which helps make the frontend look more modern. The main aim is to continuously upgrade and maintain the UI framework and libraries.

How Lang Graph helps

Lang Graph can capture each step of your upgrade process — such as decisions on breaking changes, deprecation handling, or migration patterns. For instance, if you refactor Angular 12 code to Angular 17 using specific design patterns (like moving from ngOnInit to Signal-based APIs), Lang Graph records the entire decision flow.

Next time, when a similar upgrade is needed, the system can recall this process and suggest exact migration steps, tools used, or even reusable scripts — making your future upgrades faster, more consistent, and less error-prone.

Knowledge Graph + Vector DB (at the bottom of the above diagram)

All the code, knowledge, and design information is saved in a smart format so the agents can use it later.
It’s stored in something called a Vector Database, which is optimized for search and AI use.

Similarly, it will be true for all the below projects:

Code Generation Agent: Automatically writes pieces of code.
Code Level Design Agent: Checks if your code follows good design practices.
Debugging Agent: Helps find and fix bugs.
Testing Agent: Writes unit test cases and integration test cases. And Etc

Let us now walk through a hypothetical but entirely feasible use case: rethinking the Software Development Life Cycle (SDLC) using Agentic AI.

Developer Assist project is it works in SDLC in different phases:

1. Requirement Gathering

An Agent named RequirementsBot interfaces with stakeholders via chat or email, captures business needs, and logs them into a central project document.
It uses retrieval-augmented generation (RAG) to validate similar historical features and auto-classify requirement types.

2. Specification & Planning

ArchDesigner agent reads the requirements, maps them to architectural patterns, and drafts system designs (e.g., microservices, API contracts).
TimelineBot collaborates with a human PM to create a Gantt chart, resource estimates, and delivery sprints.

3. Development

The devGen agent takes specs and scaffolds codebases using standard libraries and applies secure-by-default practices.
Paired with a CodeReviewer agent that constantly validates code quality, flags complexity, and ensures style compliance.

4. Testing & QA

TestSmith automatically generates unit, integration, and regression test suites.
Agents run tests in isolated containers, provide feedback coverage metrics, and auto-prioritize flaky tests.

5. Deployment & Monitoring

DeployAgent ensures CI/CD pipelines are green and coordinates rollout across staging and production.
OpsGuardian monitors system health, auto-generates incident reports and escalates anomalies.

This workflow runs as a collaborative agentic mesh — loosely coupled, fully observable, and modular.

The SDLC isn’t dying. It’s evolving. And agents will lead the way.

All right, enough theory — let’s dive into setting up Developer Assist.

You can download the code from my GitHub repository: https://github.com/AnimeshKumar-Sinha/developer-assit-ai

The project is built to analyze a codebase using AI agents that interact with a Knowledge Graph, check the first image, enabling tasks like debugging, generating tests, Q&A, etc.

Note: For the security module, you will have to disable it, or you can configure it; I will disable it locally for the time being.

Check the code without detailed descriptions; developers should understand it themselves.

Important code flow in this project:

Check the code without detailed descriptions; developers should understand it themselves.

Developer-Assist Code Flow: I have tried to explain it in a “A Beginner-Friendly” manner.

Step 1: User Interaction

You (or your UI/frontend app) initiate a request — this could be a question about the codebase, a request to generate a test or an LLD plan.

Example:

“What does this function do?”

“Generate integration tests for this flow.”

This request goes to the Web API.

Step 2: Web API Layer

Main file: main.py + app/routers/

This is where FastAPI receives your request.

Depending on the endpoint you hit (e.g., /message, /conversations/, /parse), your request is routed to the relevant logic.

Think of this as the receptionist forwarding your request to the correct department.

Step 3: Agent System

Main file: agent_factory.py in app/modules/intelligence/

Here’s where the magic starts. The agent system determines:

What kind of agent should respond (e.g., Q&A, debugger, code generator)
What tools and data it need to answer
How to structure its reasoning (this is where agent prompt logic lives)

Each “agent” is like an intelligent assistant trained to solve specific kinds of problems using code context.

The chat agent system is a core part of Developer-Assist—it handles interactive conversations with agents (like Q&A, debugging, and test generation). Let’s break down how the chat agent folder and related flow work step by step.

Purpose of Chat Agent Module

To enable AI agents to:

Understand user questions
Retrieve the correct context/code
Use tools
Respond intelligently with reasoning

It does this by combining:

Prompt templates
Tool outputs
LLM reasoning
Chat history

Think of it as the orchestrator.

Step 4: Knowledge Graph Tools

Folder: app/modules/intelligence/tools/

Before answering, the agent might need to:

Fetch related code files
Check recent changes
Get the structure of a module or class

These tools interface with the Knowledge Graph to extract structured context. Think of tools as specialized AI lenses that let agents “see” your code.

Step 5: Knowledge Graph System

Folder: graph_service/ + app/modules/graph/graph_ops.py

This component runs on Neo4j, a graph database. It stores relationships between files, classes, methods, and changes.

The agent uses this to understand things like:

What modules depend on each other
What function got updated in the latest branch
What are the test coverage gaps

The knowledge graph is like a map of your codebase.

Step 6: Task Queue (Async Work)

Main: celery_worker.py + docker-compose.yml

Some tasks (like parsing huge repos or running analysis) are offloaded to Celery, a task queue system. Redis is used as a message broker to manage these background tasks.

This ensures fast responses to users without blocking the API.

Response Generation

Once the agent gets the info it needs and processes your query, it sends the response back through the API. You see it on the UI or receive it in your script.

And boom — you’ve just talked to a custom AI agent powered by your codebase.

Summary (Map to Files)

Note: A developer who wants to learn the agentic AI can deep in each of this file, which I will do next.

What’s Next?

Run ./start.sh and visit localhost:3000
Try uploading a repo and interacting with it
Explore each module slowly — maybe start with tools

Core Components of Developer Assist AI

Note:

When I installed it locally, I set up the software listed below on my Mac laptop. You may need to do something additional, depending on your configuration:

python3.10 -m venv venv
source venv/bin/activate
pip install –upgrade pip
pip install -r requirements.txt

Note:
The application runs on local Docker Compose.

The final Software UI looks like the below one:

Read another article written by author at https://journals-times.com/2025/05/16/genie-space-framework-making-data-simple-for-business-users/

Fetch Data from Data Lake- Microservices Data Architecture