ShipIt’s Post

Your AI code reviews are burning tokens they don't need to. Every time Claude reviews your code, it re-reads the entire codebase. 200 files. 150,000 tokens. For a change that touched 8 files. That's not smart. That's expensive. code-review-graph fixes this. It's an open-source tool that builds a persistent, incremental knowledge graph of your codebase using Tree-sitter and SQLite. Instead of dumping your entire repo into Claude's context, it sends only the changed files plus every file impacted by those changes. The result? 5 to 10x fewer tokens per code review. Before: 200 files scanned, ~150k tokens used. After: 8 changed + 12 impacted files, ~25k tokens used. Here's what makes it practical for real engineering teams: Works natively with Claude Code via MCP (Model Context Protocol). No extra setup, no new workflow to learn. Increments intelligently. After the first build (~10s for 500 files), subsequent updates take under 2 seconds. Only re-parses what changed. Understands blast radius. It traces dependency chains so Claude knows not just what changed, but what else that change could break. Supports 12+ languages out of the box: Python, TypeScript, JavaScript, Go, Rust, Java, C#, Kotlin, Swift, Ruby, PHP, and C/C++. Needs no external database. SQLite is all it takes. The architecture is clean: Tree-sitter parses your code into an AST, a SQLite + NetworkX graph stores the relationships, git diff drives incremental updates, and 8 MCP tools expose everything to Claude Code. Three review workflows ship with it: /code-review-graph:build-graph /code-review-graph:review-delta /code-review-graph:review-pr Whether you're a junior engineer just getting into AI-assisted development or a senior architect thinking about LLM cost optimization at scale, this tool addresses a real problem: context window efficiency. AI code review should be precise. Not brute-force. Check it out: https://lnkd.in/giHvG8pR #AIEngineering #ClaudeCode #LLM #TokenOptimization #CodeReview #OpenSource #DeveloperTools #SoftwareEngineering #MCP #GenAI

Better context = Better AI. Kept thinking about this while working on some related AI stuff at the office. I needed a codebase context provider that wasn't limited to just Python, GO or TypeScript ... Introducing 𝗞𝗮𝗼𝘀 𝗔𝗦𝗧 🚀 An intelligent bridge between deep AST parsing and semantic search for AI coding tools - irrespective of the Language used! By wrapping CocoIndex-code with code_ast's tree-sitter capabilities, it creates a plug-and-play MCP server that understands the exact boundaries of your code structure. No more truncated snippets or lost context. Tech stack: 🔹 Python & Tree-sitter 🔹 Local Vector Search (LMDB/SQLite) 🔹 Model Context Protocol (MCP) Ready to use with Claude, OpenCode, and more. P.S. Real Numbers in the comments Give it a spin: https://lnkd.in/g3pyUcEF

Ran into an interesting repo: OpenHarness (or just `oh`) - an open-source clone of Claude Code, rewritten from scratch in Python. The folks at HKUDS compressed everything by a factor of 44: 11k lines vs. 512k in the original, while covering ~80% of the functionality. 43 tools out of 44, compatibility with anthropic/skills and claude-code plugins, MCP, permissions, hooks, multi-agent, a React/Ink TUI. Works with any backend via `ANTHROPIC_BASE_URL` - the README has an example with Kimi (which is kind of a hint). There's a non-interactive mode via `-p` with JSON output, so you can call it as a subprocess from your own scripts. Essentially it's a clean "agent harness" without the guts like telemetry, OAuth, and etc. They position it as a research project: if you want to understand how a modern coding agent is built under the hood - here's a minimal readable implementation, take it apart piece by piece. The architecture is laid out extremely neatly: engine / tools / skills / plugins / permissions / hooks / coordinator. The repo is fresh, still few stars, I wouldn't drag it into production. But as an architectural reference for your own agent projects - very interesting. https://lnkd.in/d5GRuhgx #ai #claudecode #llm #agent

I wrote a second article on dev.to about Microsoft's Agent Framework, this time exploring its Workflow system. The use case: converting Word documents into rich Markdown files with AI-generated image descriptions, the kind of asset you'd feed into a RAG pipeline. I started with three sequential agents and ended up, five iterations later, with a workflow where only one node calls the LLM. The other three are pure Python. The key insight: wrapping agents in Executors and wiring them into a graph makes it natural to evolve the architecture. You can swap an agent-based node with a deterministic one without touching anything else. The best LLM call turned out to be the one I didn't make. Full walkthrough from v1 to v5, with code for parallel vision calls, deterministic Markdown assembly, and the template + filler pattern. All code on GitHub (https://lnkd.in/da-YA6Km). #AI #AgentFramework #Python #OpenAI #Microsoft #Workflows https://lnkd.in/d-uipwJn

Quite often Agent needs to have some logic, like data processing, orchestration of multiple tool calls, or conditional logic. Common approach would be either make Agent to do this or have some Sandbox and then have some scripting in it. First one would waste tokens, second one requires sandboxing and wastes CPU resources. To solve this, here is Bashkit, in-process Bash with in-memory file system. Basically your Agent can have full execution engine runnig scripts in microseconds, in the same process as your app. Implemented in rust, with Python and TypeScript bindings and integrations in probably any popular AI Agents framework, like LangChain Agents, LangChain Deep Agents, Vercel AI, Pydantic AI. Couple of use cases: 1. "code mode" - idea when API surface is exposed via CLI tools inside Bash, and so Agent can call hundreds or thousands tools via single tool (or + seconds tool for discovery) 2. Tool Results token optimization - where instead feeding whole tool result to context, it post processed via bash script (grep, awk, jq) 3. Tool call orchestration - simple cases when your agent need to go via paginated API calls, easy to do with simple loop in bash 4. Math - yeh, agents not always good at math. Bash is okay: `a=1;b=-3;c=2;echo "scale=5;d=$b*$b-4*$a*$c;(-($b)+sqrt(d))/(2*$a);(-($b)-sqrt(d))/(2*$a)" | bc -l` Enjoy )

OpenAI updates Agents SDK, adds sandbox for safer code execution: OpenAI’s updated Agents SDK helps developers build agents that inspect files, run commands, edit code, and handle tasks within controlled sandbox environments. The update provides standardized infrastructure for OpenAI models, a model-native harness that lets agents work with files and tools on a computer, and native sandbox execution for running tasks safely. The new harness and sandbox capabilities launch first in Python, with TypeScript support planned for a future release. Additional features, including code mode … More → The post OpenAI updates Agents SDK, adds sandbox for safer code execution appeared first on Help Net Security.

🚀 Built & Open-Sourced: A Production-Ready LLM Workflow Engine in Python Over the past few months, I kept running into the same problem: ➡️ LLM apps don’t fail at prompts. They fail at orchestration. What starts simple quickly becomes: – multi-step pipelines – retry logic everywhere – branching flows – zero visibility into execution So I built something focused on that layer. protokol-core 👉 https://lnkd.in/dfA5wZWq 💡 What this actually solves: • Orchestrating multi-step LLM workflows cleanly • Managing retries, failures, and branching logic • Keeping execution fully explicit (no hidden state) • Designing systems that are easy to debug and extend ⚙️ What makes it different: • Minimal, dependency-light core • Composable workflow primitives • Deterministic execution model • First-class support for nested flows / subflows • Clear separation of logic vs execution • Built for real-world systems, not toy demos 🧠 Key idea: LLMs are not the hard part anymore. Workflow + control flow + reliability is. And most frameworks abstract that away… until you actually need control. 🎯 The gap: Most people can build: “prompt → prototype” ✅ Very few can reliably build: “multi-step system → production” That’s where things break. This project is focused entirely on that transition. If you’re working on: • AI platforms • LLM infra • Developer tools • Production AI systems You’ll probably relate to this. Try it. Break it. Extend it. Curious to hear how others are solving this. ⭐ https://lnkd.in/dfA5wZWq #Python #AIEngineering #SystemDesign #LLM #BackendEngineering #BuildInPublic

Most AI agents can write code. A missing layer in many agent stacks is secure, stateful code execution. I’m open-sourcing "Python Interpreter Service" a secure, session-based Python execution backend for LLMs and autonomous agents. I have also introduced MCP support, so the service can be run with Docker and plugged directly into MCP-based agent workflows. One command to get started: git clone (Repo link) && cd python-interpreter-service && cp .env.example .env && docker-compose -f docker-compose.hardened.yml up -d Sandboxed execution. Persistent sessions. REST + MCP. Browser-based package management. Repository: https://lnkd.in/dE9csd4d The project is fully open source, and I’m inviting contributors across security, integrations, testing, documentation, and developer experience. #OpenSource #Python #MCP #AIAgents #LLM #DeveloperTools #Github