Reverse-Engineering AI CLI Architecture with Python and React

Built an Advanced Personal Assistant from scratch. Here's what it actually does. Started with a blank Next.js project and a FastAPI skeleton. The result is Ava — an AI assistant that reasons, remembers, and acts across sessions. The stack: Next.js 16 · FastAPI · SQLite · Groq API · Python Groq handles inference at blazing speed. Everything else — memory, plugins, sessions, file operations — runs on your own machine. ● Agentic tool calling: The LLM doesn't just respond — it decides. Every message goes through an orchestration loop that determines whether to answer directly or invoke a tool. Weather, time zones, calculations, web search, GitHub stats, crypto prices — all fire as live tool calls with transparent execution blocks in the UI. ● Multi-model fallback cascade: If the primary model hits rate limits, the system silently falls back through a chain of models without breaking the conversation. The user never sees an error. ● Code execution: Ava writes Python, runs it in a sandboxed subprocess, reads the output, fixes errors, and iterates — all in a single turn. The full execution trace is visible inline . ● Persistent memory: After every conversation, a background extraction pass pulls facts, preferences, and events into a structured vault. Location, tech stack, habits — remembered across sessions without any manual tagging. ● Voice and Vision: Push-to-talk via MediaRecorder piped to Groq Whisper for transcription. Image upload routes to a vision model for analysis, OCR, and structured extraction. ● Dynamic plugin system: Install and uninstall tools at runtime. Register a custom skill by uploading a markdown file — the parser extracts the schema and makes it callable immediately, no backend changes required. ● Session archive: Every conversation is stored and browsable. Restore any past session back into the live chat with one click. The hardest parts were never the features themselves. They were the details — preventing tool call JSON from truncating mid-generation, stripping internal reasoning tokens before they reach the UI, making a free tier feel unlimited through intelligent model routing. The gap between a working demo and a reliable product is where most AI projects fall apart. This one doesn't. Happy to go deep on any part of the architecture in the comments. #llm #nextjs #fastapi #python #ai #groq #softwaredevelopment #webdevelopment

Vibe coding is a trap that will eventually break your production environment. Speed is an illusion when you do not understand the underlying logic. You prompt an AI, copy the TypeScript component into your Next.js project, and the tests pass. It feels like peak productivity until a major traffic spike hits. Suddenly, your Spring Boot backend crashes because that AI-generated search component lacked a simple debounce function. It fired a new SQL database query on every single keystroke. At 3:00 AM, the system is down and AI cannot read your specific server logs to save you. This is exactly when the senior engineer logs in, reads the stack trace, and spots the missing logic. They deploy a two-line fix and restore the application in exactly eight minutes. The difference is not typing speed, but the possession of a complete mental model of the architecture. If AI writes code beyond your limits of comprehension, you cannot debug it when it fails. I build my frontend and backend systems by understanding the core logic first, rather than relying on generated output. You must choose to get slower now to become exponentially faster later. Here are three architectural rules to survive the AI era: -Build mental models before writing logic. Do not delegate core architectural decisions to an LLM. -Isolate AI to boilerplate. Use it to scaffold basic Spring Boot configurations or Tailwind layouts, never for critical execution paths. Master system debugging. -Reading raw server logs and understanding database execution plans will outlast any prompt engineering trend. #SoftwareEngineering #WebDevelopment #Nextjs #SpringBoot #TypeScript #Java #SystemArchitecture #DeveloperProductivity #CleanCode

Stop debugging your AI Agents in the dark. Building with LangGraph is powerful, but once you add parallel nodes and cycles, the "black box" problem becomes real. Staring at terminal logs to find a state mutation error is a massive productivity killer. I built the Agent Debugger & Visualizer to solve this. It is a real-time observability layer that lets you step inside the agent's brain and change its mind mid-execution. Engineering Highlights: Human-in-the-Loop (HITL): Pause any node, manually edit the state JSON in the UI, and hit "Resume" to steer the agent in a new direction. State Diffs (RFC 6902): No more digging through 500-line JSON blobs. I’m tracking deltas so you see exactly what changed after each node execution. Real-time Cost Attribution: Every node tracks its own token usage and dollar cost in real-time. Async Critic Scoring: A background LLM scores agent reasoning without blocking the main execution loop. Tech Stack: Frontend: Next.js 14 & React Flow (Vercel) Backend: FastAPI & LangGraph (Render) Streaming: Redis Streams for low-latency trace delivery. Check out the demo and code: 🎥 Video Demo: https://lnkd.in/ecvxMDVx 🚀 Live Tool: https://lnkd.in/eE_AcsWD 💻 GitHub: https://lnkd.in/e9pUCHvw I am currently looking for my next challenge in the AI and Software Engineering space. If you are building agentic workflows and want to talk about observability or distributed systems, let’s connect! #AI #LangGraph #Python #SoftwareEngineering #OpenSource #LLMOps #NextJS #FastAPI

Reading a new codebase is one of the most underrated hard problems in engineering. You clone a repo. 40 files. No docs. You're lost for an hour before writing a single line. I built Codebase Explainer to fix that — a tool that takes any GitHub repo and gives you an AI-generated map of what it actually does. How it works: → Paste a GitHub repo URL → GitHub API fetches the file tree and source → Groq API (Llama) reads the code and generates plain-English explanations per module → D3.js renders an interactive graph showing structure and dependencies The interesting engineering problems: Context window management — You can't dump an entire repo into an LLM call. Had to design a chunking strategy: summarize files individually, then synthesize at the module level. Two-pass architecture. GitHub API constraints — Rate limits hit fast on public repos without auth. Built token-based auth handling to stay within limits without breaking the flow. D3.js with dynamic data — D3 is powerful and painful. Making the graph actually readable (not a hairball) with real repo data required intentional layout decisions, not just default force simulation. What this is really about: Most AI dev tools wrap GPT in a chatbox. This one produces a visual artifact — something you can navigate, not just read. That distinction shaped every design decision. What I'd add next: Cross-file dependency tracing. Right now it's file-level. Making it symbol-level (function calls, imports) would make it genuinely production-useful. Tech stack: Frontend: React + Vite Backend: Node.js + Express AI: Groq API (for code explanation/summarization) Visualization: D3.js (dependency/structure graphs) External API: GitHub API (repo fetching) Deployment: Render, Vercel GitHub: https://lnkd.in/gaXiVsK9 Live Link: https://lnkd.in/gsuEV73y #DevTools #React #D3js #AI #GroqAPI #FullStack #MERN #BuildInPublic #OpenSource

 Bridging the gap between Machine Learning and Production: An Uncertainty-Aware Forecasting System 🌤️ Most weather apps give you a single deterministic number. But in the real world, data is rarely 100% certain. I’ve spent the last few weeks building a weather forecasting system that doesn't just predict the temperature—it communicates confidence ranges and handles real-time environmental data. Key Engineering Highlights: 🔹 Machine Learning: Uses an XGBoost Regressor for recursive 7-day forecasting, with dynamic uncertainty calibration (95% confidence intervals). 🔹 Live Data Anchoring: Integrated the Open-Meteo API to ensure forecasts are anchored to real-world "Day 0" conditions. 🔹 Modern Stack: Built a decoupled architecture using FastAPI (Python) for the logic and React + Tailwind CSS for a premium, dark-mode UI. 🔹 DevOps & Deployment: Fully containerized using Docker & Docker Compose for seamless environment management. Moving from monolithic Python scripts to a modern, containerized Full-Stack architecture was a massive learning experience in system design and dependency management. Check out the full source code and documentation in the comments below! 👇 #MachineLearning #ReactJS #Python #FastAPI #Docker #FullStack #BuildingInPublic #CSStudent #DataScience

I reverse-engineered Claude Code's architecture four times from the outside. Then 512,000 lines of TypeScript leaked from a missing .npmignore. Some of my analysis was right. The three-layer context system I mapped (microcompaction, auto-compaction, structured rehydration) matched the source almost exactly. Tool routing lives in prompts, not code. The orchestration layer is thinner than anyone expected. Some of it was wrong. And the parts I got wrong are more interesting. The source reveals a 29% false claims rate in production telemetry. 250,000 wasted API calls per day from abandoned sessions. Regex-based sentiment detection. A hidden autonomous daemon called KAIROS that chains tasks without human checkpoints. An undercover mode where the agent hides that it's AI. This codebase makes $2.5 billion a year. The conventional take is that the code is garbage and Anthropic should be embarrassed. I think the opposite. They built exactly the right amount of software for the problem. Not less, not more. Every shortcut has a business justification. Verification debt isn't just real. It's profitable. https://lnkd.in/dEjhcx8N

Refactoring a complex codebase is usually a guessing game. Standard linters will catch your syntax errors, but they completely miss the silent architectural drift, hidden coupling, and "God modules" that quietly suffocate your project over time. To fix this, I just released the 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲-𝗮𝘂𝗱𝗶𝘁 skill for my 𝗺𝗮𝗱-𝘀𝗰𝗶𝗲𝗻𝘁𝗶𝘀𝘁-𝘀𝗸𝗶𝗹𝗹𝘀 Claude Code plugin. It’s a 10-phase structural audit that turns unpredictable refactoring into a precise, systematic process. Unlike generic code reviewers, this skill grounds its findings in established methodologies: Hexagonal Architecture, Domain-Driven Design (DDD), SOLID, and the Twelve-Factor App. But the real magic is its core principle: 𝗷𝘂𝗱𝗴𝗺𝗲𝗻𝘁 𝗼𝘃𝗲𝗿 𝗽𝗿𝗲𝘀𝗰𝗿𝗶𝗽𝘁𝗶𝗼𝗻. It understands that a structural choice (like mixing computation and I/O) that is an anti-pattern in a business app might be the exact right approach in a data pipeline. It looks for concrete harm, not just rule-following. I used it to drive a massive refactor of the Luxury Lakehouse. The audit surfaced 56 specific findings, giving Claude the exact context needed to execute the refactor predictably. The results from a single feature branch: 🔍 𝗜𝗻𝘀𝘁𝗿𝘂𝗺𝗲𝗻𝘁𝗲𝗱 𝟭𝟭 "𝗿𝗼𝗴𝘂𝗲" 𝗶𝗻𝗴𝗲𝘀𝘁𝗶𝗼𝗻 𝗺𝗼𝗱𝘂𝗹𝗲𝘀 that had been operating entirely outside the system's lifecycle and cost-tracking boundaries. 🏗️ 𝗦𝗽𝗹𝗶𝘁 𝟳 𝗺𝗮𝘀𝘀𝗶𝘃𝗲 "𝗚𝗼𝗱 𝗺𝗼𝗱𝘂𝗹𝗲𝘀" (each >800 lines) into focused, single-responsibility components. 🔄 𝗘𝗹𝗶𝗺𝗶𝗻𝗮𝘁𝗲𝗱 ~𝟮,𝟰𝟬𝟬 𝗹𝗶𝗻𝗲𝘀 𝗼𝗳 𝗰𝗿𝗼𝘀𝘀-𝗱𝗲𝗽𝗹𝗼𝘆𝗺𝗲𝗻𝘁 𝗱𝘂𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻 between the Python wheel and the Docker image. 🔒 𝗘𝘅𝘁𝗿𝗮𝗰𝘁𝗲𝗱 ~𝟭𝟬𝟬 𝘂𝗻𝘃𝗮𝗹𝗶𝗱𝗮𝘁𝗲𝗱 𝗦𝗤𝗟 𝗾𝘂𝗲𝗿𝘆 𝘀𝘁𝗿𝗶𝗻𝗴𝘀 scattered across 14 UI state modules into a dedicated, clean data access layer. 🛡️ 𝗜𝗺𝗽𝗹𝗲𝗺𝗲𝗻𝘁𝗲𝗱 𝘀𝘁𝗿𝗶𝗰𝘁 𝗖𝗜 𝗰𝗼𝗻𝘁𝗿𝗮𝗰𝘁𝘀 to enforce dependency direction, ensuring the architecture doesn't just decay again next month. If you want to keep your codebase structurally sound as it scales, check out the new skill in the repository: https://lnkd.in/eGyUbAZe #SoftwareArchitecture #Refactoring #DomainDrivenDesign #CleanArchitecture #ClaudeCode #AI #DataEngineering #Python

I just spent months debugging my own AI-generated code. The result? A JavaScript Visualizer that finally shows what's actually happening behind the scenes. Quick test — without running this, what prints first? Promise.resolve().then(() => console.log(1)); setTimeout(() => console.log(2), 0); queueMicrotask(() => console.log(3)); console.log(4); Most beginners memorize the answer. Almost nobody understands why. The "why" lives in the call stack, the microtask queue, the macrotask queue, and the event loop — concepts that are practically invisible in a normal debugger. So I built a tool that makes them visible. ▶️ Watch the call stack push and pop, line by line ▶️ See setTimeout park in Web APIs, then graduate to the task queue ▶️ Watch promise callbacks line up as microtasks ▶️ See the event loop pick the next job in real time ▶️ Live memory graph — stack frames on the left, heap objects on the right ▶️ Every step annotated with the actual ECMAScript spec reference Built almost entirely with AI. It took months. The hard part wasn't the UI — it was making the simulated runtime match the real one. I had to fix async/await microtask ordering, super.method() resolution in class hierarchies, TDZ when parameters shadow outer consts, try/finally semantics on early return, await rejection inside try/catch — and 40+ other edge cases. After 48 differential tests against real Node.js, the engine finally produces identical output. I have a planning to deploy it soon. If you teach JavaScript — or you're still learning it — this is going to save you (or your students) weeks of confusion. #JavaScript #LearnJavaScript #WebDevelopment #BuildInPublic #AI #EventLoop #AsyncJavaScript #FrontendDev #100DaysOfCode #CodingJourney #SoftwareEngineering #Programming #DeveloperCommunity #JSVisualizer #TechTwitter

Excited to share my latest project: an AI-powered document query system Over the past few weeks, I built a full-stack application that lets users upload documents and interact with them using natural language — basically turning static files into something you can actually talk to. One thing I really focused on was getting the pipeline right. Instead of writing everything in one script, I used LangGraph to structure the RAG pipeline as a stateful workflow. This helped me clearly separate each step — document parsing, chunking, embeddings, vector search, and final response generation. The biggest advantage? It made the system way easier to debug, extend, and scale. Plus, handling more complex queries feels much cleaner when the state is properly managed. Under the hood, the system combines semantic search with LLM reasoning to return context-aware answers instead of generic responses. Tech stack I worked with: • Backend: Python, FastAPI, Uvicorn • AI/ML: LangChain, LangGraph, OpenAI • Vector DB: Qdrant • Database: PostgreSQL • Frontend: React (Vite) + Tailwind CSS • Infra: Docker & Docker Compose Would love to hear if others are experimenting with LangGraph or RAG pipelines — always open to learning and improving! Git Repo: https://lnkd.in/gUJMvxRs #AI #MachineLearning #RAG #LangChain #LangGraph #FastAPI #React #Docker #Qdrant #PostgreSQL

Bridging the Gap Between Web Development and AI Architecture Most tutorials show you how to call an LLM API. But in production, "just calling an API" is a recipe for a crashed server and a frustrated user. To wrap up our recent Python & Django bootcamp with Django Rwanda, I delivered a final session on building Production-Ready RAG (Retrieval-Augmented Generation) Systems. I’m sharing the full presentation today to help both beginners and experienced engineers understand that RAG isn't just about AI, it’s about a reliable data pipeline. Key takeaways included in the guide: - The Worker Pattern: Why you should never run AI logic inside a standard Django view (and how Celery saves your UX). - Observability as a Priority: Using the Django Admin as a "Command Center" to make invisible ingestion errors visible. - Beyond Simple Search: Why Hybrid Search (Vector + Keyword) is the standard for accuracy. - The Re-ranking Layer: How to move from simple "mathematical similarity" to true contextual relevance. - Whether you are just starting with Python or you are a Senior Architect looking to integrate LLMs into your stack, I hope this provides a clear mental model for your next project. #DjangoRwanda #PythonRwanda #AI #SoftwareArchitecture #RAG #DjangoRwanda #SoftwareEngineering