Anthropic Leaks Source Code Due to Simple Mistake

Day 07: Cracking the "Non-Divisible Subset" Logic 🧩 Today was a true test of algorithmic thinking. I tackled a problem that looks like a standard array search but is actually a brilliant exercise in Number Theory and Remainder Math. The Challenge: Given a set of numbers, find the maximum size of a subset where the sum of any two numbers is not divisible by K The Strategy (Remainder Frequency): Instead of checking every possible pair (which would be very slow), I focused on remainders . If two numbers sum to a multiple of K, their remainders (r1+r2)  must sum to K. const s = [19,10,12,10,24,25,22]; const k = 4; function nonDivisibleSubset(k, s) { let freq = new Array(k).fill(0); // count remainders for (let num of s) { freq[num % k]++; } let count = 0; // remainder 0 case if (freq[0] > 0) count++; // check pairs for (let i = 1; i <= Math.floor(k / 2); i++) { if (i === k - i) { // special case when k is even if (freq[i] > 0) count++; } else { count += Math.max(freq[i], freq[k - i]); } } return count; } console.log(nonDivisibleSubset(k,s)) Key Takeaway: When a problem involves divisibility, don't look at the numbers—look at the remainders. It turns a complex pairing problem into a simple counting one! One full week of coding done. The momentum is real! 🚀 #JavaScript #Algorithms #NumberTheory #100DaysOfCode #CodingChallenge #ProblemSolving #SoftwareEngineering

𝗔𝗻𝘁𝗵𝗿𝗼𝗽𝗶𝗰 𝗾𝘂𝗶𝗲𝘁𝗹𝘆 𝗿𝗲𝗻𝗮𝗺𝗲𝗱 𝘁𝗵𝗲 𝗖𝗹𝗮𝘂𝗱𝗲 𝗖𝗼𝗱𝗲 𝗦𝗗𝗞. 𝗜𝘁'𝘀 𝗻𝗼𝘄 𝘁𝗵𝗲 𝗖𝗹𝗮𝘂𝗱𝗲 𝗔𝗴𝗲𝗻𝘁 𝗦𝗗𝗞. The rename isn't branding. It's a statement about what this library actually is. Before, it was a way to script the Claude Code CLI from your own code. After, it's a production-grade agent framework that exposes Claude Code's entire engine — the tool loop, the context management, the permission system, the subagent orchestration — as a Python or TypeScript library you import into your app. 𝗧𝗵𝗶𝘀 𝗶𝘀 𝘁𝗵𝗲 𝗳𝗮𝘀𝘁𝗲𝘀𝘁 𝗽𝗮𝘁𝗵 𝘁𝗼 𝗮 𝘄𝗼𝗿𝗸𝗶𝗻𝗴 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻 𝗮𝗴𝗲𝗻𝘁 𝘁𝗼𝗱𝗮𝘆. You don't define tools. You don't implement the messages.𝗰𝗿𝗲𝗮𝘁𝗲 / 𝗰𝗵𝗲𝗰𝗸 𝘀𝘁𝗼𝗽_𝗿𝗲𝗮𝘀𝗼𝗻 / 𝗲𝘅𝗲𝗰𝘂𝘁𝗲 / 𝗹𝗼𝗼𝗽 𝗽𝗮𝘁𝘁𝗲𝗿𝗻 every framework tutorial makes you write. You import `𝗾𝘂𝗲𝗿𝘆`, pass `𝗮𝗹𝗹𝗼𝘄𝗲𝗱_𝘁𝗼𝗼𝗹𝘀`, and Claude runs the loop. Four primitives do the work the raw 𝗔𝗣𝗜 asks you to build from scratch. Permissions control what the agent is allowed to touch. 𝗛𝗼𝗼𝗸𝘀 let you log, block, or transform anything the agent does. 𝗦𝘂𝗯𝗮𝗴𝗲𝗻𝘁𝘀 split specialised work off the main thread. Sessions persist context across calls. 𝗠𝗖𝗣 servers plug in through a single option. Your existing `.𝗰𝗹𝗮𝘂𝗱𝗲/` directory — skills, slash commands, CLAUDE.md — loads by default. What you used to wire up in three hundred lines of scaffolding now fits in ten. Bookmark this. You'll need it the next time someone on your team asks why you're still hand-rolling a tool loop. #ClaudeCode #ClaudeAgentSDK #Anthropic #AIEngineering #AgenticAI #AIAgents #AIDevelopment

The Builder's Take 🦀 I forked claw-code's Rust port last night. Here's my honest take as someone who runs an autonomous agent company on Claude Code every day: The leak didn't teach me that Claude Code was good. I already knew that — I run CrawDaddy, an autonomous security scanner, on it 24/7. What the leak taught me is why it's good. The architecture is minimal by design. The agent loop is simple. The power comes from tools, permissions, and context management — not from some secret proprietary reasoning layer. That means the open-source community can actually replicate it. Sigrid Jin did overnight what most teams would spend months on. The Python rewrite is honest about its gaps (there's literally a parity_audit.py file tracking what isn't done yet). The Rust port is in progress. 58,000 forks in 48 hours means this is getting finished whether Anthropic likes it or not. Why does this matter for builders? If claw-code matures, the cost of running agentic workloads drops dramatically. No API dependency. Local inference. Full control over the execution harness. For a swarm like SELARIX — where agents need to earn their existence through ROI — lower inference costs directly expand what's possible. I'm not betting production on it today. But I'm watching it closely and contributing where I can. Every scar is a credential. Every leak is a curriculum. 🔗 Fork: https://lnkd.in/dJaA59Gt 🔗 Original: https://lnkd.in/dzxkGKf6 #BuildInPublic #AgenticAI #ClawCode #OpenSource #SELARIX #CrawDaddy #Bittensor #AIAgents #RustLang

Anthropic accidentally leaked Claude Code's entire source code. 512,000 lines of TypeScript across 1,900 files, shipped in an npm update. A developer built the entire thing in Python within a few hours with the help of a couple of humans and a few AI agents. The repo became the fastest growing in GitHub history. Half a million lines of production code from one of the best funded AI companies on the planet, rewritten in a few hours. This is proof that writing code is not the bottleneck anymore. Agents do that. The hard part now is thinking clearly, designing the system, and knowing what to build and why. Thinking is software engineering now.

“Your code works… but would it survive 100,000 users?” That’s the question most developers ignore. Until it’s too late. After getting comfortable with Arrays / Lists, one thing became very clear… 👉 In real-world systems, efficiency is NOT optional — it’s survival. Let’s break it down 👇 Imagine you’re building: a booking platform or an e-commerce system At the start: ✅ 100 users → everything feels fast But then growth hits: • 10,000 users • 100,000 users • Millions of requests per day Now your “working code” faces reality: ⚡ Either it performs smoothly or 🐌 It becomes the bottleneck that breaks everything This is where Time Complexity (Big-O) quietly decides your fate. • O(1) → Instant (best case for lookups, caching) • O(log n) → Scales beautifully (search, indexing) • O(n) → Works… until it doesn’t 💥 Real-world truth: That innocent “loop through all records” can turn into a production nightmare. 🧠 What we can do differently: • Eliminate unnecessary loops • Choose the right data structures • Think about scale before it breaks 💡 Final takeaway: Good code runs. Great code scales. And understanding Time Complexity is where that shift begins. What’s one performance mistake you’ve made (or learned from)? 👇 #DSA #SystemDesign #Scalability #Programming #Python #WebDevelopment

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

Claude Code's source code leaked via an npm .map file and enthusiasts and tinkerers are already analyzing the code. Anthropic will DMCA the original, but a Python rewrite is already circulating and that's legally untouchable. What did we actually learn? * CLAUDE.MD gets loaded on every single turn — 40,000 characters of context that most people (myself included) have barely touched. That's now changing. * Parallelism is a first-class citizen. Three execution models for sub-agents: fork (shared cache), tmux pane (file-based mailbox), and git worktree (isolated branch per agent). Running a single agent is the slow path. * The permission system was never meant to ask you anything. Every prompt is a configuration failure. There's a settings.json for a reason — use it. * Compaction is the real secret sauce. Five modes, from micro-compact (clearing stale tool results) to full session summarization. The insight: what the model forgets matters as much as what it remembers. * 66 built-in tools, split into concurrent (read-only, parallel) and serialized (mutations, one at a time). Clean architecture. The broader point: Claude Code's edge isn't just the harness — it's the harness tuned specifically for the Claude model family. The prompt design and the model co-evolved. For everyone building agentic systems: this is a rare chance to study production-grade agent architecture at scale. The insights around context management, sub-agent orchestration, and permission design will propagate through the open-source ecosystem fast.

3 months. 3 prototypes. Here's the breakdown. I started 2026 with one goal: move my ideas to prototype phase and don't keep it just for myself. This is what Q1 looked like: 1. ProjectHack - a web app for early-career developers: people finish courses but can't build or explain a project end-to-end. What it does: pick your level, get a scoped project idea, follow the steps, export a CV-ready summary. Stack: Django, Tailwind, SQLite. Build time: ~12 hours. 2. Compute Specs DB - a CPU/GPU spec database with API Problem: datacenter hardware specs are scattered across vendor pages and outdated wikis. I needed a reliable source. What it does: search, filter, compare, and visualize 170+ manually validated CPU specs. REST API included. Stack: FastAPI, SQLite, Plotly. Build time: Few hours building, and another 6-10 data validation. 3. LocalUtilityBox - a local CLI toolkit published on PyPI: simple file tasks (convert HEIC, compress PDF, extract audio) mean uploading files to websites you don't trust. What it does: 28+ CLI commands that run entirely on your machine. Images, PDFs, media, OCR, QR codes. Optional GUI included. Stack: Python, published via pipx. No uploads. No accounts. Build time: 12-20h with all debugging included. All three are live. All three solve something I actually ran into and I am happy that I started doing it. None of them are finished products. That's fine. The goal was never perfection. It was to build the habit of shipping, get real feedback, and decide what's worth continuing. Q2 starts now :) Let's keep going! I added links to those projects in the comments if you r interested! #BuildInPublic #FromIdeaToPrototype #Python #OpenSource #SideProjects #CLI #FastAPI #ProductThinking #CareerGrowth #Tech

Stumbled across this open-source Claude Code configuration and honestly it's one of the most complete AI dev setups I've seen publicly shared. 91k+ stars. Called everything-claude-code. Here's what's packed inside: The scale of it: → 28 language-specific agents (TypeScript, Python, Go, Rust, Kotlin, Java, database and more) → 116 skills covering everything from TDD workflows to security reviews to frontend and backend patterns → 59 commands including /plan, /code-review, /e2e, /security-scan, /evolve → 34 rules across 6 languages What makes it actually useful: → 15+ hooks that auto-load context at session start and save state at session end → SQLite state store tracking session history and skill confidence scores → 14 MCP configurations for GitHub, Supabase, Vercel, Railway and more → AgentShield security scanner running 1282 tests across 102 rules What makes it practical: → Selective install so you only pull what you need → Cross-platform across Claude Code, Codex, Cursor and OpenCode Built by an Anthropic hackathon winner. That detail matters. GitHub link: https://lnkd.in/dwk28CSF #AI #Dev #ClaudeCode #OpenSource #DeveloperTools

🚀 Mastering a Classic Algorithm: Balanced Parentheses (Stack – LIFO) Today I revisited a fundamental problem that every Software Engineer should understand: validating balanced parentheses using a stack. Why it matters: This pattern appears in compilers, interpreters, and even real-world applications like expression parsing. Here’s the idea: 👉 Use a stack (LIFO) 👉 Push opening brackets 👉 Pop and match when encountering closing brackets 👉 Ensure the stack is empty at the end Clean and efficient JavaScript implementation 👇 This is a great reminder that mastering data structures like stacks is key to solving real algorithmic problems efficiently. I’m currently building and documenting algorithm patterns here: 🔗 https://lnkd.in/ej4fNeZs #SoftwareEngineering #JavaScript #Algorithms #DataStructures #Coding #LeetCode #100DaysOfCode