DEV Community: Ayush Thakur

Introducing Potpie's Slack Integration: Bring Your Custom AI Agents to Where You Work

Ayush Thakur — Thu, 24 Apr 2025 18:17:33 +0000

Juggling between multiple platforms to access your AI Agents? We understand this problem. As devs, we thrive on speed and flow, not hunting through tabs or juggling terminals.

At Potpie, we have been working on this problem for the last few weeks and we have come up with a solution. We are super excited to announce our new Slack integration! Now you can bring your custom AI agents directly into your team's Slack workspace where communication already happens.

What is Potpie?

Potpie is an open-source platform that allows you to build and deploy custom AI agents tailored to your specific codebase. These agents can handle a wide range of tasks including debugging, code reviewing, code generation, onboarding, etc.

Check out Potpie, if you like it, a star is always appreciated! –

potpie-ai / potpie

Spec-driven development for large codebases

Potpie

Potpie turns your entire codebase into a knowledge graph - a structural index of every file, class, and function, capturing all their relationships and what each part of the code does in context of everything else. AI agents built on this graph can reason about your code with the precision of someone who wrote it - from debugging to feature development.

Quick Start

Prerequisites

Docker installed and running
Git installed
Python 3.11+ with uv

Installation

Clone the repository

git clone --recurse-submodules https://github.com/potpie-ai/potpie.git
cd potpie

Configure your environment

cp .env.template .env

Edit .env with the following required values:

# App & Environment
isDevelopmentMode=enabled
ENV=development
defaultUsername=defaultuser

# AI / LLM Configuration
LLM_PROVIDER=openai                    # openai | ollama | anthropic | openrouter
OPENAI_API_KEY=sk-proj-your-key
CHAT_MODEL=gpt-4o
INFERENCE_MODEL=gpt-4o-mini

# Database
POSTGRES_SERVER=postgresql://postgres:mysecretpassword@localhost:5432/momentum
NEO4J_URI=bolt://127.0.0.1:7687
NEO4J_USERNAME=neo4j
NEO4J_PASSWORD=mysecretpassword

# Redis & Background Jobs
REDISHOST=127.0.0.1
REDISPORT=6379
BROKER_URL=redis://127.0.0.1:6379/0
CELERY_QUEUE_NAME=dev

# Project & Repo Management
PROJECT_PATH=projects

CHAT_MODEL and INFERENCE_MODEL are used for agent…

View on GitHub

The Slack Integration

Instead of navigating to a separate interface, developers can now interact with their custom AI agents right where they’re already working — in Slack.

With the Potpie Slack App, it's as simple as installing it into your workspace. Once set up, you’ll have instant access to all your custom-built or pre-configured AI agents, ready to assist directly in your Slack channels and conversations.

It hardly takes 2 mins to setup the Potpie Slack App. Check out the Potpie's documentation and setup the Slack App.

How It Works

Once installed, using Potpie in Slack is intuitive:

Add the Potpie bot to any Slack channel
Tag the Potpie bot and ask questions or give prompt to your custom AI agents
Receive responses directly in the Slack thread

For example:

@PotpieAI Help me with the folder structure of codebase

You can also provide a live link in the prompt for the AI Agent to refer.

For example:

Understand this issue - [issue link], and help me solve this issue and provide exact code

Thanks to the Web Access feature, your AI Agent can pull in metadata from a webpage and give you a response that’s actually tailored to the context.

Key Benefits

Seamless Workflow Integration
No more context switching between tools. Your team can stay in Slack where they're already communicating and collaborating, while still leveraging the power of custom AI Agents.

Increased Team Productivity
When AI assistance is embedded directly in your team's daily communication tool, adoption happens naturally. No more training team members on yet another platform or dealing with resistance to new tools. Your developers can immediately get answers to codebase questions, debugging help, and code reviews right where they're already working.

Knowledge Sharing
When AI Agent’s responses happen in channels rather than private conversations, knowledge is automatically shared with the team. Someone's question about any specific feature in codebase, the response becomes visible to everyone, spreading information efficiently.

Getting Started Today

Ready to bring your custom AI agents into Slack? Follow the detailed guide in Potpie's documentation to get started.

The integration takes just 2 minutes to set up, but it can save your team countless hours by bringing powerful AI capabilities into your existing communication workflow.

Checkout this quick demo and start using Potpie Slack app -
// Detect dark theme var iframe = document.getElementById('tweet-1915074439147856215-379'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1915074439147856215&theme=dark" }

Try the Potpie's Slack integration and share your experience in the comments below!

Are you using AI only to write code? You're missing out

Ayush Thakur — Thu, 27 Mar 2025 17:59:23 +0000

AI in software development is no longer optional; it's essential. Using AI just to write code isn't enough, it's much more than that. AI can help in CI/CD, documentation workflows, PR reviewing, System design, and much more. As these traditional processes fall behind, AI-driven automation is becoming the new standard for efficiency and impact. Let's explore how AI transforms these critical areas.

Current State of Software Development Inefficiency

CI/CD complexity: Pipeline configuration and optimization require specialized expertise
Documentation debt: Technical documentation is perpetually outdated or incomplete
Debugging bottlenecks – Identifying and resolving issues across distributed systems is time-consuming and often reactive.
System design challenges – Ensuring scalable and efficient architectures requires deep analysis of dependencies, performance metrics, and service interactions.

AI-Driven CI/CD: Intelligent Pipeline Optimization

CI/CD pipelines have become increasingly complex, with most organizations struggling to maintain and optimize them effectively. AI transforms this landscape:

Intelligent Failure Analysis

When CI/CD pipelines fail, the debugging process is often manual and time-consuming. AI-powered systems transform this experience by:

Contextual error analysis: Parsing logs and identifying root causes
Historical pattern matching: Connecting current failures to previously resolved issues
Automated remediation: Suggesting or automatically implementing fixes for common failures

These capabilities dramatically reduce mean time to recovery for pipeline failures.

AI-Enhanced Debugging

AI-powered debugging tools help developers quickly identify and resolve performance issues in distributed systems. They analyze logs, traces, and metrics to detect anomalies, such as increased response times or unexpected error patterns. By correlating data across services, these tools provide actionable insights, reducing the time spent on root cause analysis.

Modern AI assistants like GitHub Copilot and Potpie go beyond code completion, they also assist in debugging. These tools suggest fixes, detect potential issues, and even explain complex errors within the IDE. Some tools analyze patterns in real-time, helping developers catch inefficiencies and security risks before they escalate.

You can solve a live issue present on a GitHub repo using Potpie by providing the live link of the issue. Its AI agent scrapes the issue details, analyzes the problem, identifies the root cause, and suggests solutions. This makes debugging more efficient, especially for large codebases with intricate interactions.

AI-powered System Design

AI tools help in system design by analyzing how different parts of an application interact. They identify tightly connected components, suggest better ways to separate services, and highlight areas that could slow down performance. By understanding data flow and dependencies, AI can recommend caching strategies, optimize database queries, and detect inefficient API calls. These insights help developers build scalable systems that perform well and are easier to maintain.

Some AI-powered tools, like IBM Watson AIOps and Cortex, assist in system architecture decisions by detecting patterns in infrastructure usage and predicting performance issues. AI models can also simulate different design choices, analyzing their impact on latency, resource consumption, and fault tolerance. By integrating AI into system design, teams can make more informed decisions, reduce costly redesigns, and build architectures that scale efficiently.

Translating high-level requirements into detailed technical blueprints is a critical step in System Design. You can build an AI Agent with Potpie that can handle structuring design specifications into data models, APIs, architecture, and class structures for you. By mapping dependencies and interactions, it ensures that systems remain scalable, maintainable, and optimized for real-world performance.

AI-Powered PR Reviews

Reviewing a pull request is more complex than syntax checking or linting, as it requires understanding code structure, intent, and potential side effects.

A key difficulty is context awareness, AI models must track dependencies, recognize architectural patterns, and compare changes against historical commits to detect errors. Unlike static code analysis, this demands a deeper understanding of the entire codebase, making real-time intelligent PR reviews a challenging task.

Potpie combines a knowledge graph approach with web access capabilities to review PRs more effectively. The knowledge graph helps it understand the deeper context of a codebase, mapping dependencies, data flows, and architectural patterns. Meanwhile, its web access feature allows it to analyze PRs for specific issues, such as database inefficiencies, API performance, and system bottlenecks.

AI-Generated Documentation: The End of Documentation Debt

Documentation and READMEs is perhaps the most neglected aspect of software development, despite its critical importance. AI systems are particularly well-suited for tackling documentation challenges:

Automated Code Documentation

Modern AI assistants can analyze codebases to generate comprehensive documentation that remains synchronized with the code.
These systems can create multiple documentation formats based on the same code analysis:

API reference documentation
Architecture diagrams
User guides
Onboarding materials The key advantage is that documentation can be continuously regenerated as code evolves, eliminating documentation drift.

Interactive Documentation

Beyond static documentation, AI enables interactive documentation experiences that adapt to user needs:

Contextual examples: Documentation that shows examples relevant to the specific use case
Question answering: Systems that interpret natural language questions about codebases
Code generation: Documentation that generates implementation examples on demand

These capabilities transform documentation from a static reference into an interactive learning tool.

Potpie contributes to solving documentation debt by generating real-time documentation and READMEs directly from the codebase. Its knowledge-graph approach ensures that documentation evolves alongside the code, reducing the effort required to maintain it and making it more useful for developers.

AI-Powered Planning: Smarter Roadmaps and PRDs

AI is revolutionizing project planning by integrating seamlessly with tools like Linear, Jira, and Asana to automate backlog management, roadmap planning, and resource allocation. Traditionally, planning involves manual updates, meetings, and constant adjustments, but AI-driven systems can predict bottlenecks, optimize task assignments, and keep projects aligned with business goals.

AI-Generated PRDs: Backed by Code and Context

One of the most powerful applications of AI in project planning is automated Product Requirement Document (PRD) generation. AI can analyze code repositories, project architecture, and design specifications to create PRDs that align with the project's actual requirements.

By ensuring PRDs accurately capture development needs, AI helps Product Managers gain a clearer understanding of project’s requirements, ultimately improving decision-making and communication with engineering teams. With AI-driven insights, Product Managers can proactively address potential gaps and refine requirements before development begins.

Potpie API can be integrated with Jira, Linear or an other workflow management tool to generate PRDs that are accurate and align well with the development requirements. This reduces misalignment, and helps teams stay on the same page throughout the development process.

As AI continues to transform software development, integrating AI-powered planning into workflows will ensure better alignment between product vision and execution, reducing inefficiencies and improving overall development velocity.

asdfgnh

Ayush Thakur — Thu, 27 Mar 2025 17:56:52 +0000

sdfbgnh

dfghjk

Ayush Thakur — Thu, 27 Mar 2025 17:53:21 +0000

dfghmj,k.l

x nbc c

Ayush Thakur — Thu, 27 Mar 2025 17:41:02 +0000

bdbgfngnfb

sdfngmh

Ayush Thakur — Thu, 27 Mar 2025 17:24:24 +0000

xcsdfghmj

dfghjb

Ayush Thakur — Thu, 27 Mar 2025 17:20:34 +0000

dfghjk.

wsb

Ayush Thakur — Thu, 27 Mar 2025 17:12:58 +0000

svsdbzsgd

10 Open-source Tools to build AI Agents

Ayush Thakur — Fri, 14 Mar 2025 19:04:12 +0000

I have been working with AI Agents for quite a long time. I have built multiple AI Agents to automate various tasks, and there’s still a lot to explore. While developing AI Agents, I often encounter challenges such as:

Designing effective prompts for optimal responses
Managing memory and context retention
Integrating with external APIs and databases

In this blog, I have curated some top-notch AI Agents building tools that I personally use while working with AI Agents.

1. Potpie - Build AI Agents for your codebase

When it comes to building AI Agents for codebase, multiple problems are faced by developers like lack of context awareness, security risks, and understanding complex codebase. That’s where Potpie saves us.

Potpie is an open-source platform that enables the developers to build custom AI Agents that truly understand their coplex codebase. Potpie.ai turns your entire codebase into an intelligent system by creating a detailed knowledge graph. It breaks down code into small parts to understand how everything connects.

The system builds custom AI agents that know your specific codebase inside and out. These agents can answer questions, provide recommendations, and help with complex development tasks. Developers get an intelligent assistant that understands their unique software.

Interesting use-case:

README Generator - An AI Agent that generates README file for your code
Responsiveness Optimizer - An AI Agent that makes the UI of your project responsive
Data Query Reviewer - An AI agent that analyzes database queries to detect inefficiencies and suggest optimizations

Checkout our Github Repo and give us a star⭐

potpie-ai / potpie

Prompt-To-Agent : Create custom engineering agents for your codebase

App | Documentation | API Reference | Chat with 🥧 Repo

Prompt-To-Agent: Create custom engineering agents for your code

Potpie is an open-source platform that creates AI agents specialized in your codebase, enabling automated code analysis, testing, and development tasks. By building a comprehensive knowledge graph of your code, Potpie's agents can understand complex relationships and assist with everything from debugging to feature development.

📚 Table of Contents

🥧 Why Potpie?

🧠 Deep Code Understanding: Built-in knowledge graph captures relationships between code components
🤖 Pre-built & Custom Agents: Ready-to-use agents for common tasks + build your own
🔄 Seamless Integration: Works with your existing development workflow
📈 Flexible: Handles codebases of…

View on GitHub

2. Composio - AI integrations and tooling platform

Imagine effortlessly building AI agents and integrating them with tools like Discord, Trello, Jira, or Slack. That’s the power of Composio!

Composio is an open-source platform designed to simplify AI integration while ensuring secure authentication and Multi-Channel Processing (MCP). Whether you're customizing AI agents or connecting them to your favorite tools, Composio streamlines the process while managing access control and handling interactions across multiple platforms.

Secure AI Agents – Implement authentication to control access and permissions for AI-driven workflows.
Multi-Channel AI Bots – Build agents that seamlessly communicate across Slack, Discord, and more.
Code Intelligence – Create coding agents that analyze and optimize repositories in GitHub.
Automated Summaries – Deploy AI to generate concise reports and document summaries.

Star the Composio Repo⭐

3. Langflow: Build and Visualize AI Agents with Ease

Langflow is an open-source, drag-and-drop framework for building AI agents powered by large language models (LLMs). It provides an intuitive interface to design, prototype, and deploy intelligent applications without writing extensive code.

With seamless integration with LangChain, Langflow enables you to connect various components like memory, tools, and APIs—helping you create powerful AI agents tailored to your needs.

Whether you're developing conversational AI, workflow automation, or data processing pipelines, Langflow simplifies the process with its interactive and modular approach.

Check out the Langflow Repo

4. Julep: Build Powerful AI Agents with Ease

Julep is your ultimate platform for building intelligent AI agents that can reason, plan, and take action. Designed for developers, it provides a seamless way to create and deploy AI-driven applications with memory, tool integrations, and real-time adaptability.

As an open-source, model-agnostic framework, Julep allows you to integrate with any LLM while enhancing it with external tools, APIs, and structured workflows—enabling AI agents that go beyond simple text generation.
With Julep, you can build:

AI agents that autonomously execute tasks
Workflow automation bots for research, customer support, and more
Intelligent assistants that leverage real-time data and long-term memory

Check out the Julep repo

5. AgentOps: Build, Test, and Optimize AI Agents

AgentOps is the ultimate platform for building, testing, and deploying AI agents with precision and efficiency. It supports over 400 large language models (LLMs), AI agent frameworks, and Crews, providing powerful tools for observability, debugging, and performance optimization.

With features like time travel debugging, real-time monitoring, and seamless fine-tuning, AgentOps ensures your AI agents are reliable, cost-efficient, and production-ready.

Whether you're developing autonomous workflows, intelligent assistants, or complex multi-agent systems, AgentOps streamlines the process, helping you bring AI-powered applications to life.

Check out the AgentOps Repo

6. AgentGenesis: Build Powerful AI Agents with Ease

AgentGenesis is your ultimate platform for creating advanced AI agents that can reason, adapt, and execute complex tasks. Whether you're building chatbots, automation tools, or intelligent assistants, AgentGenesis provides the foundation to develop AI-driven solutions with minimal effort.

As an open-source, model-agnostic framework, AgentGenesis seamlessly integrates with any LLM while supporting custom tools, APIs, and external data sources. This enables you to build AI agents that are truly dynamic, context-aware, and capable of handling real-world tasks efficiently.

With AgentGenesis, you can create:

AI-powered chatbots with contextual memory
Intelligent agents that automate workflows
Custom AI solutions that interact with APIs and tools

Check out the AgentGenesis Repo

7. BondAI: Build Smarter AI Agents with Ease

BondAI is a powerful platform for creating AI agents that are intelligent, stateful, and deeply integrated with external tools and data sources. Designed to enhance large language models (LLMs), BondAI enables you to build AI-driven applications that remember context, adapt to users, and automate complex workflows.

As an open-source, model-agnostic framework, BondAI seamlessly connects with any LLM while extending its capabilities with custom tools, long-term memory, and real-world data access.

With BondAI, you can build:

AI agents that integrate with external APIs and databases
Personalized assistants that retain and utilize long-term memory
Automation tools for tasks like scheduling, research, and customer support

Check out the BondAI Repo

8. Ultravox - Build Voice AI agents

Ultravox.ai is an open-source platform for building advanced voice AI agents that understand and process speech with remarkable accuracy and naturalness. Designed to bridge the gap between human conversation and AI interaction, Ultravox empowers developers to create intelligent, responsive, and truly conversational voice experiences.

As a multimodal Large Language Model (LLM) framework, Ultravox seamlessly integrates speech and text, enabling agents to understand nuances like tone and pauses, and respond in real-time. With Ultravox, you can build:

Voice AI agents that integrate with APIs and databases, responding naturally to spoken commands.
Real-time, multilingual voice assistants capable of seamless speech-to-speech translation.
Interactive voice applications that provide personalized and engaging user experiences.

Check out the Ultravox repo

9. Agno - Simplifying AI Model Management

Agno is a platform that helps developers deploy and manage AI models more easily. It provides tools to host, monitor, and improve AI applications quickly. The platform makes complex AI infrastructure simple and straightforward.

The system connects AI models with development tools seamlessly. It allows developers to focus on creating innovative applications instead of managing technical details. Agno acts as a smart bridge between AI technology and practical use.

Agno supports multiple AI models and helps optimize their performance. It offers smart tools for routing and reducing operational costs. The platform helps developers build better AI solutions with less effort.

Checkout Agno Repo

10. Vocode: Powering Real-Time Voice AI Conversations

Vocode is an open-source framework for building intelligent, real-time voice AI agents. Used at vocode.dev, it provides seamless tools to integrate large language models (LLMs) with voice-based applications, enabling natural, responsive, and context-aware conversations.

With Vocode, you can:

Create AI-powered voice assistants with real-time streaming capabilities
Build interactive customer support agents that handle complex queries
Develop workflow automation tools that execute voice commands

Designed for flexibility, Vocode supports multiple speech-to-text (STT) and text-to-speech (TTS) providers, making it easy to customize and optimize voice interactions.

Check out the Vocode Repo

Thank you for reading! Do you know any other useful AI Agent building tool? Drop them in the comments.

Creating Coding AI Agents with Ollama

Ayush Thakur — Thu, 27 Feb 2025 18:29:59 +0000

We’ve just rolled out Potpie’s multi-LLM feature, enabling developers to seamlessly integrate and switch between multiple LLMs, including Ollama, a powerful locally hosted AI solution.

With this update, developers can now use any LLM of their choice, including Ollama, to build and deploy AI Agents with greater flexibility.

This feature is powered by LiteLLM, a lightweight framework that standardizes API calls across multiple AI providers. It allows Potpie to efficiently route requests to different LLMs while handling request formatting and model-specific optimizations behind the scenes.

This feature is available in our latest release (v0.1.1), which you can access here: Potpie v0.1.1 Release

Using Ollama with Potpie to Build AI Agents

Ollama is a locally hosted LLM solution that packages large language models into self-contained bundles, including weights and configuration, simplifying deployment. Ollama allows developers to run models entirely offline, providing advantages like:

Privacy & Security – No external API calls, ensuring data remains on your machine.
Lower Latency – Faster response times without network dependency
Cost Efficiency – No API usage fees, making it ideal for frequent queries.
Customizability – Supports fine-tuning and model modifications for specific tasks.

Ollama leverages optimized libraries like llama.cpp for efficient inference on CPUs and GPUs, ensuring smooth performance even on resource-limited devices. It also features a straightforward command-line interface for managing models, making it developer-friendly and highly customizable.

Setting Up Potpie with Ollama

With this update, Potpie AI Agents can now seamlessly leverage Ollama models in a local setup, giving developers complete control over configurations. Setting up Potpie locally is straightforward, just follow our Getting Started Guide to install and configure it on your machine.

Checkout our Github Repo and give us a star⭐

potpie-ai / potpie

Prompt-To-Agent : Create custom engineering agents for your codebase

App | Documentation | API Reference | Chat with 🥧 Repo

Prompt-To-Agent: Create custom engineering agents for your code

📚 Table of Contents

🥧 Why Potpie?

🧠 Deep Code Understanding: Built-in knowledge graph captures relationships between code components
🤖 Pre-built & Custom Agents: Ready-to-use agents for common tasks + build your own
🔄 Seamless Integration: Works with your existing development workflow
📈 Flexible: Handles codebases of…

View on GitHub

Once installed, integrating an LLM requires defining four key parameters:

LLM_PROVIDER – The AI provider (e.g., OpenRouter, Ollama, etc.)
LLM_API_KEY – The API key for the selected provider
LOW_REASONING_MODEL – The model used for lightweight tasks
HIGH_REASONING_MODEL – The model used for complex reasoning

To configure Ollama, use the following setup:

LLM_PROVIDER=ollama  
LLM_API_KEY=ollama  
LOW_REASONING_MODEL=ollama_chat/qwen2.5-coder:7b  
HIGH_REASONING_MODEL=ollama_chat/qwen2.5-coder:7b

Ollama supports multiple models, and you can choose from any reasoning models it provides based on your use case.

Why Use Ollama Locally with Potpie?

Running Potpie locally with Ollama provides the ultimate flexibility and control over AI Agent development. Developers can:

Experiment with any AI model, including open-source, fine-tuned, or custom models.
Optimize inference costs, since Ollama runs entirely on local hardware without API fees.
Enhance security and privacy, as no data is sent to external providers
Improve response times by eliminating network latency.

For those using default LLMs supported by Potpie (GPT, Gemini, Claude, etc.), reasoning models don’t need to be specified, Potpie automatically selects the most suitable option. However, with Ollama, developers can customize their model selection for better performance and task-specific tuning.

Other Supported LLM Models

While Ollama is a powerful choice for local AI inference, Potpie also supports a variety of cloud-based LLMs for those who prefer API-based solutions. You can integrate any supported model using your own API keys or generate a new Potpie key.

Default LLMs Supported by Potpie:

OpenAI’s GPT – A versatile model with strong natural language understanding and code generation capabilities.
Google’s Gemini – Designed for multimodal tasks with advanced reasoning and contextual awareness.
Anthropic’s Claude – Excels in code understanding and generation, with advanced problem-solving capabilities for technical tasks.
Meta's Llama – An open-source foundation model that offers strong performance with greater customization and deployment flexibility.
DeepSeek – Cost-efficient models with strong reasoning abilities, ideal for complex problem-solving.

We are continuously expanding support for additional open-source and proprietary LLMs based on community feedback and advancements in AI.

Get Started with Potpie & Ollama Today!

Ready to build privacy-first, cost-efficient AI Agents with Ollama? Download Potpie v0.1.1 and start experimenting with local LLM inference today! Get Potpie v0.1.1 Now

I built an AI Agent that makes your project Responsive

Ayush Thakur — Fri, 21 Feb 2025 13:23:26 +0000

When building a project, I prioritize functionality, performance, and design but ensuring making it responsive across all devices is just as important. Manually testing for layout shifts, broken UI, and missing media queries is tedious and time-consuming.

So, I built an AI Agent to handle this for me.

This Responsiveness Analyzer Agent scans an entire frontend codebase, understands how the UI is structured, and generates a detailed report highlighting responsiveness flaws, their impact, and how to fix them.

How I Built it

I used Potpie to build this AI Agent.

Checkout our Github Repo and give us a star⭐

potpie-ai / potpie

Prompt-To-Agent : Create custom engineering agents for your codebase

App | Documentation | API Reference | Chat with 🥧 Repo

Prompt-To-Agent: Create custom engineering agents for your code

📚 Table of Contents

🥧 Why Potpie?

🧠 Deep Code Understanding: Built-in knowledge graph captures relationships between code components
🤖 Pre-built & Custom Agents: Ready-to-use agents for common tasks + build your own
🔄 Seamless Integration: Works with your existing development workflow
📈 Flexible: Handles codebases of…

View on GitHub

I simply provided a descriptive prompt to Potpie, specifying:

What the agent should do
The steps it should follow
The expected outputs

Prompt I gave to Potpie:

I want an AI Agent that will analyze a frontend codebase, understand
its structure, and automatically apply necessary adjustments to
improve responsiveness. It should work across various UI frameworks
and libraries (React, Vue, Angular, Svelte, plain HTML/CSS/JS, etc.),
ensuring the UI adapts seamlessly to different screen sizes.

Core Tasks & Behaviors-

Analyze Project Structure & UI Components:

Parse the entire codebase to identify frontend files

Understand component hierarchy and layout structure.

Detect global styles, inline styles, CSS modules, styled-components, > etc.

Detect & Fix Responsiveness Issues:

Identify fixed-width elements and convert them to flexible layouts (e.g., px → rem/%).

Detect missing media queries and generate appropriate breakpoints.

Optimize grid and flexbox usage for better responsiveness.

Adjust typography, spacing, and images for different screen sizes.

Apply Best Practices for Responsive Design:

Add media queries for mobile, tablet, and desktop views.

Convert absolute positioning to relative layouts where necessary.

Optimize images, SVGs, and videos for different screen resolutions.

Ensure proper touch interactions for mobile devices.

Framework-Agnostic Implementation:

Work with various UI frameworks like React, Vue, Angular, etc.

Detect framework-specific styling methods

Modify component-based styles without breaking functionality.

Code Optimization & Refactoring:

Convert hardcoded styles into reusable CSS classes.

Optimize inline styles by moving them to separate CSS/SCSS files.

Ensure consistent spacing, margins, and paddings across components.

Testing & Validation:

Simulate different screen sizes and device types (mobile, tablet, desktop).

Generate a report highlighting fixed issues and suggested improvements.

Provide before/after visual previews of UI adjustments.

Possible Techniques:

Pattern Detection (Find non-responsive elements like width: 500px;).

Detect and suggest better styling patterns

Based on this prompt, Potpie generated a custom AI Agent for me.

How it Works

The Agent operates in four key stages:

In-Depth Code Analysis – The AI Agent thoroughly scans the entire frontend codebase and creates a knowledge graph to thoroughly examine the components, dependencies, function calls, and layout structures to understand how the UI is built.
Adaptive AI Agent with CrewAI – Using CrewAI, the AI dynamically creates a specialized RAG agent that adapts to different frameworks and project structures, ensuring accurate and relevant recommendations.
Context-Aware Enhancements – Instead of applying generic fixes, the RAG Agent intelligently processes the code, identifying responsiveness gaps and suggesting improvements tailored to the specific project.
Generating Code Fixes with Explanations – The Agent doesn’t just highlight issues—it provides exact code changes (such as media queries, flexible units, and layout adjustments) along with explanations of how and why each fix improves responsiveness.

Generated Output Contains

Analyzes the UI and detects responsiveness flaws
Suggests improvements like media queries, flexible units (%/vw/vh/rem), and optimized layouts
Generates the exact CSS and HTML changes needed for better responsiveness
Explains why each change is necessary and how it improves the UI across devices

By tailoring the analysis to each codebase, the AI Agent makes sure that projects performs uniformly to all devices, improving user experience without requiring manual testing across multiple screens.

Here's an Output:

I built an AI Agent that creates README file for your code

Ayush Thakur — Thu, 06 Feb 2025 14:59:22 +0000

As a developer, I always feel lazy when it comes to creating engaging and well-structured README files for my projects. And I’m pretty sure many of you can relate. Writing a good README is tedious but essential. I won’t dive into why—because we all know it matters.

So, I built an AI Agent called "Readme Generator" to handle this tedious task for me. This AI Agent analyzes your entire codebase, deeply understands how each entity (functions, files, modules, packages, etc.) works, and generates a well-structured README file in markdown format.

I used Potpie to build this AI Agent.

Checkout our Github Repo and give us a star⭐

potpie-ai / potpie

Prompt-To-Agent : Create custom engineering agents for your codebase

App | Documentation | API Reference | Chat with 🥧 Repo

Prompt-To-Agent: Create custom engineering agents for your code

📚 Table of Contents

🥧 Why Potpie?

🧠 Deep Code Understanding: Built-in knowledge graph captures relationships between code components
🤖 Pre-built & Custom Agents: Ready-to-use agents for common tasks + build your own
🔄 Seamless Integration: Works with your existing development workflow
📈 Flexible: Handles codebases of…

View on GitHub

I simply provided a descriptive prompt to Potpie, specifying what I wanted the AI Agent to do, the steps it should follow, the desired outcomes, and other necessary details. In response, Potpie generated a tailored agent for me.

The prompt I used:

I want an AI Agent that understands the entire codebase to generate a
high-quality, engaging README in MDX format. It should:

Understand the Project Structure

Identify key files and folders.

Determine dependencies and configurations from package.json, requirements.txt, Dockerfiles, etc.

Analyze framework and library usage.

Analyze Code Functionality

Parse source code to understand the core logic.

Detect entry points, API endpoints, and key functions/classes.

Generate an Engaging README

Write a compelling introduction summarizing the project’s purpose.

Provide clear installation and setup instructions.

Explain the folder structure with descriptions.

Highlight key features and usage examples.

Include contribution guidelines and licensing details.

Format everything in MDX for rich content, including code snippets, callouts, and interactive components.

MDX Formatting & Styling

Use MDX syntax for better readability and interactivity.

Automatically generate tables, collapsible sections, and syntax highlighted code blocks.

Based upon this provided descriptive prompt, Potpie generated prompts to define the System Input, Role, Task Description, and Expected Output that works as a foundation for our README Generator Agent.

Here’s how this Agent works:

Contextual Code Understanding - The AI Agent first constructs a Neo4j-based knowledge graph of the entire codebase, representing key components as nodes and relationships. This allows the agent to capture dependencies, function calls, data flow, and architectural patterns, enabling deep context awareness rather than just keyword matching
Dynamic Agent Creation with CrewAI - When a user gives a prompt, the AI dynamically creates a Retrieval-Augmented Generation (RAG) Agent. CrewAI is used to create that RAG Agent
Query Processing - The RAG Agent interacts with the knowledge graph, retrieving relevant context. This ensures precise, code-aware responses rather than generic LLM-generated text.
Generating Response - Finally, the generated response is stored in the History Manager for processing of future prompts and then the response is displayed as final output.

This architecture ensures that the AI Agent doesn’t just perform surface-level analysis—it understands the structure, logic, and intent behind the code while maintaining an evolving context across multiple interactions.

The generated README contains all the essential sections that every README should have -

Title
Table of Contents
Introduction
Key Features
Installation Guide
Usage
API
Environment Variables
Contribution Guide
Support & Contact

Furthermore, the AI Agent is smart enough to add or remove the sections based upon the whole working and structure of the provided codebase.

With this AI Agent, your codebase finally gets the README it deserves—without you having to write a single line of it.

Here's an Output: