Stable Tool Update: Configuration Guide and Bug Fixes

I almost gave up on backend development in my first year. Not because it was hard. Because I didn't see the point. Writing APIs that just moved data from A to B felt mechanical. No creativity. No impact. Just endpoints and responses. Then I connected my first automation to a real workflow. A script that pulled data, processed it, and triggered actions automatically, no human involved. Something that used to take hours happened in seconds. And I thought, wait. This is what the code is actually for. Not just moving data. Building systems that give people their time back. That's the moment backend development stopped feeling like a job and started feeling like a craft. If you're early in your dev journey and feeling stuck, it gets better. Find the problem your code actually solves. That changes everything. What made you fall in love with what you do? 👇 #Python #SoftwareEngineering #ArtificialIntelligence #BuildInPublic

🚨 #50K #stars 💫💫💫 in #2HOURS and still counting. 🤯🤯 with currently #100K forked on GitHub #SameDay Not days. Not weeks. #Two. #Hours. 👉 #ClawCode : https://lnkd.in/g_3-3Zf2 And yes… I already forked it the moment it dropped.😀😀😀😊😊😊 At first, people thought it was just: 👉 a leaked version of Anthropic #ClaudeCode But what happened next is what really matters… 💥 The creator (behind #instructkr) didn’t just post it— he turned it into something usable almost immediately And then… ⚡ started porting it to Python in #ONE #night. Then, release to #Rust in #ONE #day 🦀 That’s when it clicked for me: 🤯This is not a leak anymore. This is becoming a real system. 🧠 What makes this repo different? ❤️🔥It’s not about prompts. ❤️🔥It’s not about chat. ❤️🔥It’s about a true agent harness: ➡️ Plan ➡️ Generate ➡️ Execute ➡️ Observe ➡️ Fix ➡️ Repeat 👉 It doesn’t stop at an answer 👉 It keeps going until the task actually works 🔥 After playing with it a bit, my biggest takeaway: The #magic is NOT the #model. It’s the loop + execution + feedback design ⚙️ This could go even bigger 🤯 than OpenClaw. → real execution → self-correcting system → end-to-end task completion 👉 It feels like the early version of a self-operating engineer 📰 Even The Wall Street Journal is covering the rise of “vibe coding” tools (#ClaudeCode, #Cursor, #Codex …) But this feels like the next step: 💡 Not “AI helping you code” 💡 But AI owning the entire coding loop 📊 My takeaway (after forking + testing day 1): We’re entering a new phase: 💫Model = brain 💫Harness = system 💫Loop = intelligence And honestly… 👉 This might be the moment where software design starts mattering more than model size ⚡ 50K stars in 2 hours isn’t just viral. It’s the community saying: 👉 “THIS is the direction.” #AI #Agents #LLM #OpenSource #Python #Rust #VibeCoding #FutureOfWork #Opensource #ClaudeCode

🚀 pyresilience — 7 resilience patterns in 1 decorator 💡 What is resilience? Your app keeps working even when dependencies fail, slow down, or overload. No crashes. No hanging. Just smart recovery. ⚠️ Pain point: Python teams often stitch together: • Retries ("tenacity") • Circuit breakers ("pybreaker") • Timeouts ("asyncio", "signal") • Rate limiting ("limits", "slowapi") • Fallbacks (custom code) 👉 These don’t coordinate → messy + inconsistent failure handling 📊 Existing tools: • "tenacity" (retries ~263.6M downloads/month) • "pybreaker" (circuit breaker ~9.6M downloads/month) 👉 Great individually, not unified ⚡pyresilience Benchmark: 🚀 pyresilience → 0.64 μs (🔥 ~10.4x faster) 🐢 tenacity → 6.64 μs 🛠️ What pyresilience does: One decorator with: ✅ Retry ✅ Circuit Breaker ✅ Timeout ✅ Fallback ✅ Bulkhead ✅ Rate Limiter ✅ Cache ➡️ Works together, not glued ➡️ Zero dependency ➡️ Sync + Async ➡️ High performance Frameworks: 🌐 FastAPI • Flask • Django 👨💻 For all Python developers 🔗 GitHub: https://lnkd.in/d-SRygNQ 🔗 PyPI: https://lnkd.in/dRg2H4D5 🔗 Docs: https://lnkd.in/dxZ4xYkw 💬 How are you handling resilience in Python today? #Python #SoftwareEngineering #BackendDevelopment #PythonDev #Microservices #DistributedSystems #FastAPI #Django #Flask #ResilienceEngineering #SystemDesign #FaultTolerance #OpenSource #DevTools #BuildInPublic

I have been thinking less about agents and more about paths. A lot of software still assumes execution is: - an app flow - an async mesh - or an agent stack But human work usually looks messier and more real: you carry something, fork, test, return, defer, resume, and only sometimes settle. So I have been exploring a path-style runtime where: - push opens a fork - pop rejoins or abandons a fork - skills attach to the path - memory keeps residue - repeated signals reinforce instead of just duplicating noise The interesting question is not “what is the next token?” It is more like: - what is still being carried? - what changed direction? - what can be deferred? - what actually needs to settle? I may post a tiny Python demo of path execution next. https://lnkd.in/eairkdJK #runtime #systems #paths #softwarearchitecture

Shipped ShipIt-agent v1.0.0 An open-source Python agent runtime for building powerful, production-style agents with a clean API. What’s in it: - Multiple LLM support - AWS bedrock/OpenAI / Anthropic / Gemini / Groq / Together / Ollama via adapters - prebuilt tools for web search, open URL, workspace files, code execution, memory, planning, verification, artifacts, AskUser, human review - MCP support for remote tool discovery and tool execution - connector-style tools for Gmail, Google Calendar, Google Drive, Slack, Linear, Jira, Notion, Confluence, and custom APIs - session history, memory stores, trace stores, and structured streaming packets - notebook test flows for no-tools, multi-tools, MCP, connectors, AskUser, HILT, streaming, and reasoning Built so you can do things like: - create an agent with llm, tools, mcps, prompt, history - stream live runtime events and tool packets - plug the agent into chat products or internal workflows - inspect reasoning with visible planning / decomposition / synthesis / decision tools GitHub: https://lnkd.in/dpUiYqzF #python #ai #llm #agents #mcp #opensource #bedrock #toolcalling

🚀 pyresilience — 7 resilience patterns in 1 decorator (~1000 downloads last month 🔥) 💡 What is resilience? Your app keeps working even when dependencies fail, slow down, or overload. No crashes. No hanging. Just smart recovery. ⚠️ Pain point: Python teams often stitch together: • Retries ("tenacity") • Circuit breakers ("pybreaker") • Timeouts ("asyncio", "signal") • Rate limiting ("limits", "slowapi") • Fallbacks (custom code) 👉 These don’t coordinate → messy + inconsistent failure handling 📊 Existing tools: • "tenacity" (retries ~263.6M downloads/month) • "pybreaker" (circuit breaker ~9.6M downloads/month) 👉 Great individually, not unified ⚡pyresilience Benchmark: 🚀 pyresilience → 0.64 μs (🔥 ~10.4x faster) 🐢 tenacity → 6.64 μs 🛠️ What pyresilience does: One decorator with: ✅ Retry ✅ Circuit Breaker ✅ Timeout ✅ Fallback ✅ Bulkhead ✅ Rate Limiter ✅ Cache ➡️ Works together, not glued ➡️ Zero dependency ➡️ Sync + Async ➡️ High performance Frameworks: 🌐 FastAPI • Flask • Django 👨💻 For all Python developers 🔗 GitHub: https://lnkd.in/d-SRygNQ 🔗 PyPI: https://lnkd.in/dRg2H4D5 🔗 Docs: https://lnkd.in/dxZ4xYkw ♻️ Resharing to support the Python community 🤝 💬 How are you handling resilience in Python today? #Python #PythonDeveloper #PythonDev #BackendDevelopment #SoftwareEngineering #DistributedSystems #Microservices #SystemDesign #ResilienceEngineering #FaultTolerance #HighAvailability #ScalableSystems #PerformanceEngineering #AsyncIO #FastAPI #Django #Flask #APIEngineering #CloudNative #DevOps #SRE #OpenSource #OpenSourceProject #PyPI #PythonLibraries #DeveloperTools #TechInnovation #BuildInPublic #Programming

Why “Good Enough” isn't enough for a scalable Feed. Most side projects start with a simple goal. For me, it was just fetching a backend feed and displaying it on a screen. But as soon as I hit "Refresh," I realized a feed isn't just a list of data, it’s a living ecosystem of state. The Pivot: What started as a simple GET request evolved into a deep dive into 4-Layer Architecture. I didn't just want to show posts; I wanted a system where following a user, accepting a request, and updating a sidebar felt instantaneous and "true" to the database. The Challenges (The parts that didn’t make the highlight reel): ▪️The Infinite Loop Trap: Early on, I triggered nearly 1,000 recursive errors. Using a global context meant that every time I updated a follower count, my entire navigation re-rendered, triggering another fetch. ▪️State Disconnect: There’s a specific frustration in clicking "Accept Request" and seeing the notification badge stay stuck at '1'. Solving this meant rethinking how the Service Layer communicates with the Context Layer. ▪️The "Self" Filter: It sounds simple, but ensuring a user doesn't get suggested to follow themselves requires a tight sync between the Auth state and the Suggestion engine. Why the 4-Layer approach? I moved toward a strict separation between API Services, Custom Hooks, and Context Providers. The Result: A UI that doesn't just "fetch", it synchronizes. When you confirm a follower in the Navbar, the Sidebar stats update in real-time without a page reload. Building the "feature" was easy. Building the flow that handles data consistency across three different components was where the real learning happened. Check out the demo below to see the state-sync in action. 👇 Sheryians Coding School Sheryians Coding School Community Ankur Prajapati #WebDevelopment #ReactJS #NodeJS #SheryiansCodingSchool #FullStack #SoftwareEngineering #Coding #Cohort2

Stop counting lines of code. Start counting the ones you deleted 🗑️ There’s a common misconception that more code = more work. In reality, more code usually = more bugs, more technical debt, and more headaches. I’ve been mentoring my team on a simple standard: If you can do it in fewer lines without losing clarity, do it. It doesn’t matter if you’re working in React, Python, or Node.js—reducing the "noise" in your codebase is a game-changer. Here’s why: 1. Reviewing is faster: A 20-line PR gets a much deeper, more effective review than a 200-line one. 2. Debugging is easier: It’s hard for a bug to hide in a clean, concise function. 3. Onboarding is seamless: New team members should be able to read your code like a book, not a puzzle. We’ve implemented standards like guard clauses, utilizing modern syntax, and strict functional purity. The result? Our codebase is leaner, our team is faster, and our "WTFs per minute" during code reviews has hit an all-time low. My challenge to you: 🫵 Next time you finish a feature, take 10 minutes to see if you can achieve the same result with 20% less code. Your future self (and your team) will thank you. #CleanCode #SoftwareEngineering #ProgrammingTips #TechLeadership #DeveloperExperience #CodingStandards #Jayabal #Minimalism #PR #MergeRequest

Most developers don’t write bad code on purpose. Bad code usually starts as “just for now.” A quick fix. A shortcut to meet a deadline. Something you plan to clean up later. But “later” rarely comes. Over time, those small decisions compound: simple changes become risky bugs take longer to trace onboarding gets harder performance issues appear unexpectedly Bad code doesn’t just fail — it resists change. It hides intent, uses inconsistent naming, and tightly couples logic so everything depends on everything else. You spend more time understanding it than improving it. Good code is different. It’s clear, intentional, and built for change. you can read it and understand it quickly names explain purpose components are loosely coupled edge cases are handled deliberately Good code reduces mental overhead. It makes change easier. Some principles I follow: Do: write for the next developer keep functions small and focused choose clarity over cleverness refactor when patterns emerge Don’t: don’t over-engineer don’t mix responsibilities don’t ignore edge cases don’t rely on memory Good code isn’t about speed. It’s about how easily it can evolve. I focus on building backend systems with Python, Django, and DRF that scale in maintainability, not just traffic. What’s one coding habit you had to unlearn? #BackendEngineering #CleanCode #Django #SoftwareArchitecture #TechGrowth

𝐓𝐡𝐞 𝐝𝐞𝐯𝐞𝐥𝐨𝐩𝐞𝐫 𝐰𝐡𝐨 𝐰𝐫𝐨𝐭𝐞 𝐭𝐡𝐢𝐬 𝐜𝐨𝐝𝐞 𝐥𝐞𝐟𝐭 8 𝐦𝐨𝐧𝐭𝐡𝐬 𝐚𝐠𝐨. 𝐍𝐨𝐰 𝐢𝐭’𝐬 𝐲𝐨𝐮𝐫 𝐩𝐫𝐨𝐛𝐥𝐞𝐦. 𝐍𝐨 𝐜𝐨𝐦𝐦𝐞𝐧𝐭𝐬. 𝐍𝐨 𝐝𝐨𝐜𝐬𝐭𝐫𝐢𝐧𝐠𝐬. 𝐍𝐨 𝐑𝐄𝐀𝐃𝐌𝐄. 𝐉𝐮𝐬𝐭 400 𝐥𝐢𝐧𝐞𝐬 𝐨𝐟 𝐥𝐨𝐠𝐢𝐜 𝐚𝐧𝐝 𝐚 𝐩𝐫𝐚𝐲𝐞𝐫. We talk about clean code. We talk about good architecture. Nobody talks about documentation. Here’s the truth: Code is written once. It’s read hundreds of times. By teammates. By future hires. By you, 6 months from now. Documentation isn’t for now. It’s for the moment someone has to touch your code at 11pm before a deployment. Will they understand it? Or will they guess? 𝐓𝐡𝐞 𝐦𝐢𝐧𝐢𝐦𝐮𝐦 𝐞𝐯𝐞𝐫𝐲 𝐜𝐨𝐝𝐞𝐛𝐚𝐬𝐞 𝐧𝐞𝐞𝐝𝐬: 1. README → What is this? How do I run it? 2. Docstrings → What does this function do? What does it return? 3. Inline comments → Why was this decision made? 4. Changelog → What changed and when? Not perfect docs. Just enough context to not be helpless. The best comment I ever read wasn’t explaining what the code did. It explained why a weird workaround existed. One line saved hours of confusion. 𝐔𝐧𝐝𝐨𝐜𝐮𝐦𝐞𝐧𝐭𝐞𝐝 𝐜𝐨𝐝𝐞 𝐢𝐬𝐧’𝐭 𝐣𝐮𝐬𝐭 𝐚 𝐭𝐞𝐜𝐡𝐧𝐢𝐜𝐚𝐥 𝐝𝐞𝐛𝐭. It’s a people problem. Someone will inherit what you write today. Document like they’re a stranger. Because eventually they will be. #Django #Python #BackendDevelopment #SoftwareEngineering #CleanCode #WebDevelopment