Building in public sounds simple until you're staring at a blank tweet trying to remember what you shipped 3 hours ago. I kept falling into the same trap: finish a coding session, feel productive, then realize I never documented anything. The "build in public" part of build in public was the bottleneck. So I built a /ship command for Claude Code. Now at the end of a session, I type /ship and Claude automatically summarizes what was built, the tech used, key changes, and impact. It posts a structured entry directly to a Notion database. The setup is surprisingly simple. The command is a markdown file in ~/.claude/commands/. It triggers a Python script that creates rich Notion pages with properties and body blocks. Zero external dependencies. Just Python's urllib and json. Each entry captures: Title, Project, Type, Tech Stack, Summary, Key Changes, Impact, Technical Details, and links to commits/PRs. The bigger picture is that these structured entries feed an automated content pipeline. Instead of writing social posts from memory, they get generated from real, structured data. The Notion DB becomes the single source of truth for everything I ship. I started with a hook that ran on every Claude response but that was way too noisy. The manual /ship approach gives you control over what gets logged and when. Gist with the full setup: https://lnkd.in/e8uV6SsP What's your system for documenting what you build?

What's a Context Graph? Think of it as custom scaffolding to guide your agentic applications through your enterprise data in the most efficient, contextual, and explainable way.

Wow, William Lyon has done it again! create-context-graph is a simple python package for standing up a complete Context Graph implementation in just a few minutes. It includes 22 industry domains out of the box (healthcare, financial services, retail, etc). It can generate synthetic sample data from one of those domains or you can create your own using a simple interactive flow modeled after create-react-app. If you want to see it with your own real data, it can pull data out of several popular SaaS applications like Slack, Notion, Gmail, etc. create-context-graph integrates with 9 different Python agent frameworks and uses neo4j-agent-memory under the hood to create short-term, long-term and reasoning memory for your agents. It also stands up a lightweight Next.js frontend with agent chat, NVL interaction visualization and decision trace / document explorer interface. It's the perfect way to get started and play around with Context Graphs for your agentic applications. Check out the link the comments. 👇 Michael Hunger Andreas Kollegger Sudhir Hasbe Philip Rathle

🚀 Every developer knows this pain. You join a new company. They hand you a massive codebase with 500+ files. Your senior is in meetings all day. And you're stuck doing Ctrl+F for a week just to understand where anything is. So I decided to build the solution. 🔍 Introducing CodeSearch — an AI-powered search engine for your codebase. Upload any repository → ask questions in plain English → get exact answers with file names and line numbers in under 3 seconds. ⚡ No more digging through hundreds of files. No more wasting your first 2 weeks just reading code. No more bothering your senior dev with basic questions. 💡 3 features that make it powerful: 🔎 Smart Search — understands context, not just keywords. Ask "how does authentication work?" and get a real answer, not a list of files. 🧠 ELI5 Explain — paste any function and get it explained like you're 5, or at expert level. Perfect for understanding legacy code instantly. 🐛 AI Bug Scanner scans your entire codebase for security issues, null dereferences, and unhandled errors. Like having a senior code reviewer on demand. 🛠 Tech Stack: Next.js · TypeScript · RAG Pipeline · LLaMA 3 · FAISS Vector DB Built using the same core architecture behind GitHub Copilot, Cursor, and Sourcegraph , which are collectively worth billions. 👨💻 Full source code on GitHub: https://lnkd.in/dRWiT9Qn #buildinpublic #nextjs #typescript #AI #RAG #MachineLearning #webdev #programming #softwaredevelopment #100daysofcode

The most impactful decision when building this frontend wasn't a line of code. It was how I architected the AI workflow around it. I created a custom subagent in Claude CLI, engineered to work exclusively with the Context7 MCP server. One server. Deliberately scoped. Context7 pulls live library documentation directly into context — so the agent was always operating on current, accurate API references, not cached training data. No hallucinated methods. No outdated signatures. Then I orchestrated a human-in-the-loop review cycle: → Agent generates a component grounded in real, up-to-date docs → I evaluate it — does it match my intent? Is the structure sound? → I approve what's right, push back on what isn't → Agent iterates The result was code I understood completely, because every architectural decision passed through my judgment first. The precision of the workflow came directly from the deliberate constraints I designed into it. The frontend is live at mestigarribia.dev — built with Tailwind CSS and Vanilla JS. The full source code is publicly available in the repository linked on the site, if anyone wants to dig into the implementation. Has anyone else engineered constrained agent workflows for specific tasks? Curious what approaches people are finding effective. #ClaudeAI #MCP #AIEngineering #Python #Developer

Library Management System | FastAPI + Streamlit I developed a full-stack Library Management System to manage books, users, and transactions through a simple and interactive interface. --> Built RESTful APIs using FastAPI to perform CRUD operations such as adding, updating, deleting, issuing, and returning books. --> Designed a user-friendly frontend using Streamlit for seamless interaction and real-time updates. --> Implemented core features like book availability tracking, user management, and transaction handling. --> Used in-memory data structures (Python dictionaries) instead of a database to focus on application logic and API design. --> Structured the project with clear separation between frontend and backend components. -->Thanks to my mentor Shaheer Shaik for guidance and support throughout the development of this project. -->This project strengthened my understanding of API development, system design, and full-stack integration. #FastAPI #Streamlit #Python #FullStackDevelopment #APIs #SystemDesign #Projects #Innomatics Streamlit (FrontEnd)     ↓ (HTTP Requests) FastAPI Backend ↓(HTTP Response) Streamlit (FrontEnd)

Reverse-Engineering the Architecture of a Modern AI CLI 🚀 Recently, the source map for a major enterprise AI CLI tool was accidentally exposed on npm (iykyk). Instead of just looking at the files, I saw an opportunity for a deep-dive architectural study. I wanted to understand exactly how top-tier engineering teams route context, manage Model Context Protocol (MCP) servers, and handle polymorphic tools at scale. So, I built a Static DAG Architecture Visualizer. Checkout here: https://lnkd.in/dGFRutw8 🛠️ How I built it: Backend (Python): I wrote a custom Abstract Syntax Tree (AST) parser to statically analyze hundreds of TypeScript files. The script uses deep Regex to extract behavioral metadata—like class inheritance (extends BaseTool), public exported APIs, and JSDoc descriptions—and compiles them into a pure mathematical dependency graph (JSON). Frontend (React + Vite): I built a highly responsive dashboard using React Flow. The Math (Dagre): To prevent the 600+ node graph from turning into an unreadable "hairball," I implemented the dagre layout engine to calculate hierarchical x/y coordinates dynamically, allowing for strict Left-to-Right data flow tracking. 💡 Key Architectural Takeaways I discovered: - The "God Class" Pattern: Almost all CLI capabilities inherit from a centralized Tool.ts interface, proving a highly decoupled, polymorphic command structure. - Terminal as a UI: The CLI heavily utilizes React Ink, treating the terminal prompt like a full-blown React web application with complex state management and dialog lifecycles. - Dynamic Domain Toggling: Dumping 600 nodes crashes the browser's main thread. I implemented a Domain Filter that isolates subsystems (e.g., Core Engine vs. MCP Integration), instantly recalculating the DAG math and preventing layout engine locking. Building tools to analyze other tools is one of my favorite ways to level up as a Full-Stack developer. If you're building complex React applications or scaling Python backends, I'd love to connect! #SystemArchitecture #ReactJS #Python #AST #SoftwareEngineering #WebDevelopment #ReactFlow

🔍 Showcasing my Friend Suggestion System I previously built an ML-powered friend recommendation system, and I’ve now deployed it to demonstrate how mutual connections and user interactions can be used to generate meaningful friend suggestions. 🔍 How it works: The system analyzes user data such as shared interests, activity patterns, and existing connections. Using similarity-based algorithms, it ranks and recommends relevant profiles. To make the concept more intuitive, I demonstrated the working using a graph-based approach (e.g., Alice → Bob → Charlie → David → Alice), where users are represented as nodes and connections as edges. This allows anyone to simulate and understand the backend process of mutual friend connections. 💡 Key Highlights: • Achieved 88% accuracy in friend recommendations • Improved user engagement by 30% • Delivered 92% user satisfaction in internal testing • Clean and intuitive user interface ⚙️ Tech Stack: Python, C++, HTML, CSS, JavaScript, File Handling,cloud hosting,Graph algorithms. ☁️ Deployment: Deployed on Render, making the system accessible for real-time simulation and better understanding of the recommendation logic. 🎥 Demo Video: In the video below, I demonstrate how the system works using a graph example to simulate real-world friend connections. 🔗 Live Demo:https://lnkd.in/gbXmGTEn 💻 GitHub Repository: https://lnkd.in/gZFNQ9u4 This deployment helped me showcase how recommendation systems and graph-based logic work together in real-world applications. Would love your feedback! 🙌 #MachineLearning #GraphTheory #WebDevelopment #CloudComputing #Render #Python #StudentDeveloper

Built a Calculator… but with a twist. Instead of using built-in evaluation functions, I challenged myself to implement a calculator using **core Data Structures & Algorithms concepts**. Used **Stack-based evaluation** Parsed expressions manually Applied **infix to postfix conversion** logic Focused on clean logic over shortcuts This project helped me strengthen my understanding of how real-world systems handle expressions internally — something we often take for granted. Key takeaway: Sometimes, building "simple" things from scratch teaches you more than complex frameworks. As a MERN developer, I’m trying to go deeper into **DSA + system-level thinking**, not just UI. Would love your feedback or suggestions to improve this further! #DSA #JavaScript #MERN #Coding #SoftwareDevelopment #LearningInPublic