Build Private AI Pull Request Reviewer on Your Machine

I built an open-source AI Code Review tool — and it works with any project in minutes. After using AI-powered code reviews on my own projects, I realized the tooling was either locked to one platform, one AI provider, or required heavy setup. So I built something better. AI Code Review is a universal, configurable tool that: - Works with GitLab MRs and GitHub PRs - Supports Claude, GPT-4o, DeepSeek, Groq, Ollama, or any OpenAI-compatible API - Has zero dependencies — pure Python, drop one file into your CI pipeline - Runs with just 2 environment variables out of the box - Lets you bring your own custom review prompt per project - Includes dry-run mode to preview comments before posting The whole thing is a single file you can curl into any CI job. Or clone the repo and customize it. 68 unit tests, full backward compatibility, and it takes less than 5 minutes to set up. Check it out: https://lnkd.in/dnPFbpWQ If you're looking to integrate AI code reviews into your team's workflow, set up custom review prompts for your stack, or need help with CI/CD automation — I'm available for consulting. DM me or reach out to discuss how I can help your team ship better code, faster. #OpenSource #CodeReview #AI #DevOps #CICD #Python #SoftwareEngineering #GitLab #GitHub #DeveloperTools

OpenAI just released an official Codex plugin for Claude Code. Two competing companies. Two competing flagship tools. Now running together. I built this exact pattern two months ago. kln-claude-codex-experts routes Claude Code tasks to 10 specialized Codex roles: security analyst, architect, adversarial reviewer, code reviewer, scope analyst, simplifier, implementer, and more. Each runs with calibrated reasoning effort. Security audits get maximum reasoning. Simple lookups get minimum. You're not overpaying for easy tasks. The key insight that both projects share: context isolation. Codex runs in its own context window (up to 1M tokens with GPT-5.4) with full repo access. Your Claude conversation stays clean. Only the structured summary comes back. Where they diverge: OpenAI's plugin gives you three modes. Standard review, adversarial review, and task handoff. Clean and simple. My approach goes deeper. 10 expert roles, diff-aware reviews that start from git changes, parallel execution via Python subprocesses, two model tiers (gpt-5.3-codex for coding, gpt-5.4 for analysis), and structured JSON output conforming to a review schema. The real story here isn't about my project or OpenAI's plugin. It's that multi-agent workflows across competing providers are becoming a standard engineering pattern. Claude for orchestration. Codex for specialized execution. The best tool for each job, regardless of who made it. Vendor loyalty is a business strategy. Engineering is about results. Left the link in the comment section #AIEngineering #ClaudeCode #OpenAI #Codex #DevTools #AI #SoftwareEngineering

🚀 Learning AI/ML in Public — Day 4: From Python Script to Production API Most ML projects die on a laptop. Today I tried taking a step towards actually shipping one. Knowing how to serve the model as a production API. Here’s the stack I worked with today: FastAPI — typed REST endpoints with auto-generated docs (didn’t know this was so smooth) Pydantic — request/response validation so bad inputs don’t reach the model Uvicorn — async ASGI server to handle concurrent requests Docker — containerise everything so it runs identically everywhere I took my RAG pipeline from Days 2-3 and turned it into: → A POST /query endpoint that accepts a question + optional metadata filters → A GET /health check for container orchestration → A Swagger UI at /docs — FastAPI generates it automatically (this surprised me) →  A Docker image deployable to any cloud with one command The biggest lesson: load your ML models at startup, not per request. Loading a sentence transformer takes 3 seconds. Multiply that by 1000 API calls and you understand why. #MLOps #FastAPI #Docker #MachineLearning #BuildingInPublic #AIML

Cursor, Claude Code, and Codex are merging into one AI coding stack nobody planned OpenAI just shipped an official plugin that runs inside Anthropic's Claude Code. Not a workaround. Not a community hack. An Apache 2.0-licensed plugin from OpenAI, installed directly into a competitor's terminal. Same week, Cursor 3 launched a rebuilt interface that treats the code editor as secondary. The default view is now an Agents Window for managing fleets of coding agents across repos and environments. Google's Antigravity reached the same conclusion with its Manager Surface. I wrote about what this means for developers - https://lnkd.in/g8QgDDhh Three layers are forming. Orchestration on top, where you manage and route agents. Execution in the middle, where coding agents write, test, and commit code. Review at the bottom, where a different model from a different provider challenges the code the first one wrote. The interesting part is the review layer. When Claude writes code and Codex reviews it, you get independent scrutiny. Different training data, different blind spots. You are no longer asking someone to grade their own homework. Nobody designed this stack. Developers assembled it because no single tool covers everything. Claude for precision on complex refactors. Codex for throughput on parallel tasks. Cursor as the control plane on top. We went through the same thing with infrastructure. Terraform, Docker, Kubernetes. Not one tool to rule them all. Composable layers that got better together. Are you already running multiple coding agents in the same workflow, or still picking one and hoping it covers everything? #AIcoding #DevTools #CodingAgents #SoftwareEngineering

As the adage in Software Engineering goes, never test your own code. In the AI-driven world of coding, the new rule is: never use the model that you used to write code to review it. I just finished reading an article by #Janakiram on how the AI coding market is not consolidating into one "winner", but is instead evolving into a specialized, three-layer stack: 1️⃣ The Orchestration Layer: Cursor 3 (specifically the new "Glass" interface) is moving beyond the editor to become a control plane for managing fleets of parallel agents. 2️⃣ The Execution Layer: This is the engine room. While Claude Code is winning on nuanced reasoning, OpenAI Codex is being tapped for high-throughput, asynchronous tasks. 3️⃣ The Review Layer: This is the game-changer. By using the new codex-plugin-cc, developers are now using Codex to provide independent, "adversarial" reviews of code written by Claude. #Janakiram makes a compelling point: we are moving away from walled gardens toward interoperability. The biggest players in AI have start building plugins for their competitors, the future seems to be about composition and not competition.

⚙️ AI CHEAT CODE #019 ⚙️ Your CI/CD pipeline is failing and you have NO IDEA why. This AI trick diagnoses it in 30 seconds ⏱️ Step 1: Copy your failing GitHub Actions log (the red ❌ output) Step 2: Paste into Claude with this prompt: "This CI/CD pipeline failure log — tell me: 1. The root cause (not just the error message) 2. Why this is happening 3. The exact fix with code 4. How to prevent this in future runs" Step 3: Get the fix, apply it to your workflow YAML Step 4: Ask: "Review my entire .github/workflows/deploy.yml for failure points and security issues" Step 5: Apply preventive fixes BEFORE they become production incidents BONUS — Ask AI to write your pipeline from scratch: "Create a GitHub Actions workflow for a Python FastAPI app that: - Runs tests with coverage - Builds Docker image - Pushes to ECR - Deploys to ECS with zero downtime - Rolls back automatically on failure" You'll get production-ready YAML in seconds 🚀 ⚡ Pro Tip: Add "explain each step so I can understand and modify it later" Learn while you ship fast! What's the weirdest CI/CD failure you've debugged? Drop it below 👇 #DevOps #CICD #GitHubActions #Automation #AI #Docker #AWS #SoftwareEngineering

🔥 I built an AI Agent that reads, understands, and debugs entire GitHub repositories. Not just file-by-file. The whole codebase , at once. After days of deep building, I'm launching GitHub Smart Agent, a production-ready AI tool that turns any GitHub repo into an interactive, intelligent assistant. What it actually does: 🔍 Ingests any GitHub repository in seconds 💬 Chats with your entire codebase like a senior dev 🧠 Detects bugs using both static analysis + AI reasoning ⚡ Suggests optimizations with context-aware explanations 📊 Generates structured analysis reports — ready to share Under the hood: → LangChain + FAISS Vector Store for RAG pipeline → OpenRouter (Gemini Flash / DeepSeek) as the reasoning engine → Custom embedding pipeline for code-aware retrieval → Streamlit with a fully custom premium UI Why I built this: Every developer has opened a legacy codebase and thought "where do I even start?" This tool answers that question in seconds. 🎬 Full demo video is live — watch it below. 🔗 GitHub repo dropping in the next day or two — I'll post when it's up. Drop a follow so you don't miss it! If you're working in AI engineering, LangChain, LLM tooling, or developer tools , I'd love to connect and exchange ideas. What's the biggest pain point you face when navigating an unfamiliar codebase? 👇 #AI #LangChain #RAG #LLM #DeveloperTools #Python #Streamlit #CodeAnalysis #OpenRouter #FAISS

Using LLMs to Automate Dockerfile Generation. #Building with LLMs: From Understanding to Implementation Over the past few weeks, I explored how Large Language Models (LLMs) actually work in real-world applications — and instead of just learning theory, I built a small project around it. 🔁 System Architecture: User → Python Script → Ollama API → LLM → Dockerfile Output 1. The Idea: What if we could automatically generate production-ready Dockerfiles using LLMs? That’s exactly what I implemented using both Local and Hosted LLM approaches. ⚙️ What I Built I developed a Python-based system where a user provides a programming language as input, and the system generates an optimized Dockerfile using an LLM. You give an input like a programming language (Python / Node.js etc.) → System generates a production-ready Dockerfile using an LLM But the focus wasn’t just output. #Implementation_Approaches: Local LLM (Ollama + LLaMA) which runs directly on my machine Hosted LLM (API-based), no infra management 📚 What I learned: 1>How to integrate LLMs into backend workflows. 2>Real difference between local vs hosted AI systems. 3>Why prompt engineering directly impacts output quality. 4>How DevOps is evolving with AI-driven automation. 🔗 MY GITHUB LINK: https://lnkd.in/g-JmYGhc #DevOps #AWS #LLM #AI #Docker #Kubernetes #Cloud #PlatformEngineering

I just pushed a repo I've been sitting on for a while — five applied AI apps in one codebase, sharing one foundation. https://lnkd.in/g86ZX_qU The apps themselves are not the point. A mini chatbot, a prompt-chaining pipeline, a YouTube summarizer, a text-to-SQL tool, and a multi-doc RAG app with citations. Each one is the kind of thing you've seen a hundred times on LinkedIn. The reason I built them this way was that I was tired of seeing AI "portfolios" that were actually five disconnected repos with five different styles of spaghetti. A folder per tutorial. No shared abstractions. A new way of calling the model in every project. You learn very little from building that, and a reviewer learns even less from reading it. So I gave myself a constraint. One repo. One shared LLMClient. One config pattern. One UI framework. Provider-agnostic from day one — OpenAI or local Ollama, swap with a line of config. No LangChain, because I wanted the patterns to be readable, not hidden behind four layers of framework. Then I built the five apps on top of that foundation, each one demonstrating a different core pattern: chat state and provider abstraction prompt chaining and structured reasoning external data ingestion and summarization natural language to SQL with safety guardrails retrieval-augmented generation with source attribution What I learned writing it this way was the thing I didn't expect: the foundation forced me to be honest about what was actually the same between these apps and what was actually different. The "same" part was much bigger than I'd assumed. Most "AI apps" are 80% plumbing you've already written and 20% the actual idea. Once the plumbing is shared, you can see the idea clearly. A portfolio of five demos teaches you how to call an API five times. A codebase teaches you architecture. I wanted the second one. #BuildInPublic #AIEngineering #AppliedAI #LLM #Python #SoftwareEngineering #OpenSource

Let’s be honest: Developers love writing code, but we hate updating the documentation. 😅 So, I spent the last few days building an AI Agent to do it for me. I’m calling it Watchtower 🏰 an autonomous AI agent that keeps technical documentation in sync with your code changes, in real-time. Here is how the architecture currently works: 1️⃣ The Ears: A FastAPI server listens for GitHub Webhooks whenever someone pushes code. 2️⃣ The Hands: It uses PyGithub to fetch the exact git diff. (I added a "Noise Filter" so it ignores massive files, deleted files, and image assets to save API costs!). 3️⃣ The Brain: Powered by LangGraph and GPT-4o, it analyzes the code logic. If the change is trivial (like fixing a typo), it ignores it. 4️⃣ The Action: If the change matters, it creates a new branch and automatically opens a Pull Request with the updated documentation for human review. Tech Stack: Python, FastAPI, LangGraph, LangChain, PyGithub. ✅ Phase 1 is complete: The end-to-end pipeline (Webhook → AI → PR) is working perfectly! Now, I need your feedback to make it better: I’m planning the next phase and considering adding Graph RAG to map file dependencies (so if you change auth.py, it knows to update payment.py docs too). For the senior engineers and open source maintainers out there: 👇 What edge cases should I look out for? What features would make you actually want to install this on your team's repo? Let me know in the comments! #BuildInPublic #AI #LangGraph #Python #SoftwareEngineering #OpenSource #OpenAI