Keith Chirayus

Up to 85% of your Claude Code tokens aren't going to reasoning or writing code. They're going to re-reading files it already read. Just rediscovering the same codebase every single turn. Someone finally sat down and measured it properly. You ask Claude something like "why does auth depend on this file?" and it greps the repo, opens a bunch of files, follows the dependency chain. Fine. But then your follow-up question? Same files. Same tokens. Same bill. That's 20-30K tokens burned per question just on context reconstruction. There's an open-source tool called GrapeRoot that fixes this. It builds a graph of your codebase once, keeps track of what's already been read, and pre-loads only the files that are actually relevant before Claude starts working. Benchmarks across 20 prompts at 5 complexity levels came back at 45% cheaper on average, and up to 85% fewer tokens on complex tasks. The part nobody expected: less noise in the context window also led to better code. Not just cheaper output. Genuinely better output. That's one of three things from this week worth knowing about. Second one. Karpathy's CLAUDE.md just hit 15K stars on GitHub. The concept is dead simple. LLMs make the same predictable mistakes when writing code. They over-engineer things, ignore existing patterns, pull in dependencies you never asked for. If you've used any AI coding tool for more than a week, you've seen all of this. The fix is one markdown file dropped into your repo root with behavioral rules for your project. Claude Code picks it up automatically. No framework, no config. Just instructions that change how the model approaches your code. If you don't have a CLAUDE.md yet, start there. Third. Someone threw Claude Code at a 10,685 file codebase with 25 bugs to fix and new features to add. The results were refreshingly honest. 15 items were perfect, no corrections needed. 6 needed minor tweaks, mostly missing fallbacks and small regressions it introduced. 1 completely failed with duplicates and wrong counts. The useful takeaway: Claude Code is genuinely great at building new things from scratch but gets unreliable when touching old, fragile code. That tracks with my own experience. New features, let it fly. Legacy refactors, read every diff line by line. All three are free. All three are things you can try this weekend. #ClaudeCode #AI #DeveloperProductivity #DevTools #CodingAgents #SoftwareEngineering

82

1 Comment

𝟳+ 𝘆𝗿𝘀 𝗲𝘅𝗽𝗲𝗿𝗶𝗲𝗻𝗰𝗲 𝗰𝗮𝗻𝗱𝗶𝗱𝗮𝘁𝗲: “𝗧𝗵𝗲𝘀𝗲 𝗾𝘂𝗲𝘀𝘁𝗶𝗼𝗻𝘀 𝗮𝗿𝗲 𝗺𝗮𝗸𝗶𝗻𝗴 𝗺𝗲 𝘂𝗻𝗰𝗼𝗺𝗳𝗼𝗿𝘁𝗮𝗯𝗹𝗲. 𝗜’𝗺 𝘀𝗼𝗿𝗿𝘆, 𝗜 𝗾𝘂𝗶𝘁 𝘁𝗵𝗶𝘀 𝗶𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄.”
𝗔𝗻𝗱 𝗷𝘂𝘀𝘁 𝗵𝘂𝗻𝗴 𝘂𝗽. Context: I was interviewing for a mid-level frontend role. Resume looked good—7+ years, React, etc. Asked standard JS stuff: how ‘this’ works, event loop, currying, prototypes. Answers were shaky, so I went a bit deeper. Then: “What happens when you type a URL in the browser? Walk me through DNS, TCP, HTTP That’s when they snapped and bailed. I’ve had people struggle, say “I don’t know,” even go silent… but straight up quitting and saying the questions made them uncomfortable and drops off the call immediately. Are core JS + basic networking no longer fair game for mid-level frontend devs? Or did I just hit a unicorn? Thoughts? For help and guidance in you carrier path https://lnkd.in/gH3paVi7 Join my dev community for resources📚, tech talks🧑🏻‍💻and learning 🧠 https://lnkd.in/gt8WeZSt 
#interviewing #javascript #frontend #hiring

30

2 Comments

With 30 minutes left in my day, I drop a stack of well-defined Linear tickets into Todo, set Amphetamine to keep my laptop awake, and close the lid. By morning, the PRs are open, CI is green, and code review comments are addressed. I haven't hand-written a PR in months. Clipboard has tripled deploys per engineer. The workflow opens 50+ PRs a day and burns 7.3B tokens a month, about $5,273 at retail API rates, but Claude Code Team and Codex Pro plans cover it. Here's the stack, three pieces of which we just open-sourced. 𝗧𝘄𝗼 𝗮𝗴𝗲𝗻𝘁𝘀. Codex is the better debugger and reviewer. Claude Code is the better designer. Two plans also (mostly) keep me under rate limits. 𝗰𝗺𝘂𝘅 𝗳𝗼𝗿 𝗽𝗮𝗿𝗮𝗹𝗹𝗲𝗹 𝘀𝗲𝘀𝘀𝗶𝗼𝗻𝘀. Ghostty-based, native notifications, and unlike Zed Parallel Agents or tools like Conductor, it runs the actual Claude Code and Codex CLIs. 𝗴𝗿𝗼𝘂𝗻𝗱𝗰𝗿𝗲𝘄 (new, open-source). Watches a Linear board and farms tickets to local agents that are more steerable than remote agents. Tracks 5-hour and weekly usage limits so overnight lint cleanup doesn't eat the headroom I need in the morning. Agents run in cmux workspaces, backed by git worktrees within agent-safehouse sandboxes, for safer YOLO modes. Shout out to Clayton Winders for the initial version! 𝗰𝗹𝗲𝗮𝗿𝗮𝗻𝗰𝗲 (new, open-source). Combines agent-safehouse's host-OS isolation with a deny-by-default HTTP proxy, so a runaway agent can't exfiltrate data. groundcrew uses it transparently. /𝗯𝗮𝗯𝘆𝘀𝗶𝘁-𝗽𝗿 (new, open-source). Watches each PR, fixes CI failures and merge conflicts, and triages every review comment three ways: — Agrees: pushes the fix and replies with the commit link and a one-line summary. — Agrees but defers: opens a follow-up PR to prevent bloat in the current one. — Disagrees: replies with why. What changed in my workflow is that the plan → ship → review → fix loop runs without me in the middle for any ticket I can specify clearly. I've moved up the stack: deciding what to build, writing the rules and feedback loops that keep agents honest, and proving the result. The three new tools are in our monorepo: https://lnkd.in/geEE7xFi. Star it if it's useful. If this is the kind of thing you want to build, we're hiring: https://lnkd.in/g78Merj4

147

22 Comments

Understanding the fundamentals of software engineering is not something optional if you want to build a long career in tech. As one advances in their life and career, many or most of my friends and colleagues got married and had children. Priorities changes drastically and as a software engineer if you solely rely on learning tools on the go then you would need to re-learn something new every week with todays rate of progress which would require considerable time and health investment away from kids and family leading to burnout and frustration. Having strong fundamentals makes picking up new technologies or reading papers or blogs or github repos easier and less time away from other responsibilities. Learning fundamentals is an investment for mid and late career progression.

23

🚧 API not ready yet? Don’t block frontend development. Extend it. I recently kicked off a greenfield React project using Relay, but the backend wasn’t fully built out yet. Rather than stub in brittle mocks or delay UI work, I leaned on Relay Client Schema Extensions to keep development moving. 🔧 I extended our GraphQL schema with mock data that gave us realistic, structured data we could query with actual Relay fragments 👥 The client schema became an API contract, making collaboration with our backend team more seamless 💡 Bonus: I used Cursor to generate Relay store update logic, saving time and boilerplate fatigue I wrote up about it here: https://lnkd.in/gGJ35-eS Curious if others are doing something similar. Have you used client schema extensions this way? How do you handle frontend momentum when the API is still a work in progress? #React #Relay #GraphQL #FrontEndDevelopment #TypeScript #DeveloperExperience #Cursor

5

Every software engineer experiences this. If you haven't, congratulations. 👏 Production failures. You know the feeling. Users complaining. Pressure rising. “How long until it’s fixed?” It happened to me. It will probably happen again. I can’t prevent every failure. But I can build systems to fix them fast. Enterprise or personal software. Same rule applies. You need a boring system that works under pressure. I started using GitHub Actions recently. Simple and predictable. Here's the flow I built to quickly address production errors. 👇 P.S. What was the last production issue you had to fix?

1

I love this blog post. Many of us are coming to the same conclusion: Clean code is not dead, and in fact, is as important as ever. https://lnkd.in/gu3a75Ar I’ve been thinking a lot about Sandi Metz’s teaching lately (and always). Sandi talks about getting to “shameless green.” The tests pass, the code works, but it’s not necessarily pretty. You refactor into an implementation that is open to change *just when* you have requirements driving it. In some ways, coding agents have caused us to take a step back; we often never get past shameless green, instead of letting new requirements drive refactors that make the next change easier. The irony is that while it’s never been easier to push shameless green to its most shameful, it’s also never been easier to take to a moment to restructure. Even the most powerful models, using structured plans, helpful plugins, reasonable configurations, all the bells and whistles, will absolutely tie themselves in knots when faced with tricky problems and code that is not open or well structured. But developers are rediscovering what we already knew: the best code is that which is easy to change. We’re also, finally, refreshing our docs so that the agents don’t trip over old stuff that no longer works - another practice that had known value all along. As the post says, the same things that help humans, help agents. Future models will surely handle complexity better, or will diverge from humans in what shape of code they handle best, but in the current landscape, the machines and us are not so different. Everyone and their LLM’s mother is trying to solve the two great problems of agents: context, and direction (you could even say it’s the same problem). How do we make the best use of context windows? And how do we get these toddlers-with-PhDs (the agents) to do what we want? There is a boatload of money being thrown around to solve these problems. But what if the answer to both, at least in part, were the principles we already knew? We just have to follow them. 

12

2 Comments

Experienced developers tell me that the hard part of the job interview isn't figuring out the best way to solve the problems they pose for you, but guessing what *they* think is the right solution or approach. And, you might not be surprised to hear, what *they* think is the right solution or approach can sometimes be just plain batty. I appreciate how frustrating that can be. But looking on the bright side, at least now you know. Some employers forget that the candidate is also interviewing *them*.

35

4 Comments

I have a message for dev hiring managers and aspiring developers you haven't heard yet. It has never been a better time to start a development career. There is a structural shift in the entry point. Employers just don't get this, but dev managers do. Companies will follow. Previous generations spent years getting bogged down in the mechanics of code before they got anywhere near the higher-order problems. Syntax. Debugging line by line. Building pattern libraries the slow way. The work that builds judgment was buried out of reach, under the work of just getting the code to run. AI removes that bottleneck. Early-in-career developers today have a tool that produces working code on demand and traces root cause faster than most senior developers can. That frees them to spend time on the skills that actually determine whether a system succeeds: defining constraints precisely, evaluating output against real conditions, and building the architectural discipline that separates reliable systems from fragile ones. There are still hard things to learn. Knowing when to stop generating and start validating. Finding experienced developers who will give honest feedback. Building judgment that only comes from operational exposure. None of that is easy, and AI does not shortcut it. But you will need to learn fast, quicker than ever. Get to production fast. Let what you observe drive what you build next. Be ready to learn again, and again, as the AI-Human dev dynamic continues to change. Be a constant learner. Be resilient. And read my report - link in the comments. The Futurum Group DevOps.com Techstrong.IT

19

5 Comments

I submitted my PR today. A senior engineer asked one question. I had no answer. "What is the time complexity of this loop?" In PHP, I never faced this question. In Spring Boot, reviewers ask it. Big O is not a theory problem. It is a PR problem. Here are the 6 you need to know before your next review: - O(1) is HashMap.get(). Always 1 step. - O(log n) is binarySearch(). Halves the work each time. - O(n) is a for-each loop. One pass per item. - O(n log n) is Arrays.sort(). The floor for any sort. - O(n^2) is a nested loop. 100 items equals 10,000 steps. - O(2^n) is naive recursion. It will never pass review. Save this list before your next PR. Which one trips engineers up most on your team?

105

4 Comments

Just give me 10 seconds, I’ll explain in simple words why Kafka and why gRPC. In system design, we often need our services to talk to each other. And two popular ways of doing that are Kafka and gRPC. But they’re very different in how they work and more importantly, when to use them. Kafka is like “Bhai, main message daal raha hoon, tu jab free ho tab padh lena.” It’s asynchronous. So one service sends a message (like “order placed”), and other services (like inventory, email, analytics) will pick it up whenever they’re ready. No need to wait. It’s great for decoupled, event-driven systems where things happen in the background. gRPC, on the other hand, is like calling someone and saying, “Bro, mujhe abhi data chahiye.” It’s synchronous, super-fast, and mostly used inside systems where two services need to talk instantly like “get user details” or “check payment status”. It uses Protocol Buffers, so the data is small and fast to transfer. - Kafka is best when services don’t need to wait and things can run in the background. - gRPC is best when you need quick, real-time response from another service. Simple funda: Kafka for events, gRPC for direct calls. Depends on the use case both have their own vibe. #systemdesign #hld

41

1 Comment

System Design is Becoming a MUST-Have Skill for Every Modern Engineer A few years ago, system design was something you only needed for senior roles or big tech interviews. Not anymore. What I’m Seeing in 2026: Real-time features AI integrations Scalable backends Secure data handling And without strong system design… things break fast. The Mistake Most Developers Make: They focus on: ❌ Frameworks ❌ Libraries ❌ Syntax But ignore: 👉 How everything connects and scales What System Design Actually Means in Real Projects: It’s not diagrams. It’s decisions like: ✔ How your API layer handles load ✔ How your database scales with users ✔ How your backend manages real-time data ✔ How your AI features process requests efficiently ✔ How you secure authentication and user data Example (Simple but Real): Building a chatbot? That’s not just: API call → response It’s: Request handling Context storage Rate limiting Cost optimization Response streaming 👉 That’s system design. Why This Matters Now: The difference between: A working app ❌ A scalable product ✅ Is system design. What I’m Focusing On: Designing systems that: Scale from 100 → 100,000 users Integrate AI + real-time data Stay fast, secure, and cost-efficient If you're a developer in 2026, ask yourself: 👉 Can I build features… or can I design systems? #SystemDesign #SoftwareEngineering #Backend #Scalability #AI #Developers #Tech #FullStack

2

Coding agents need access to real secrets. But traditional approaches like copying credentials into files or maintaining long-lived tokens create unnecessary risk and slow teams down. If you're navigating this shift, I think you'll find real value in this upcoming live session. Wednesday, April 22nd at 9 AM PDT / 12 PM EDT,  Sidharth Sudhir, Developer at @1Password, and Hugo Charre, Field Engineer at @Cursor, will walk through a practical framework for secure AI-powered development. You’ll learn:  ✅ Why just-in-time secrets are the safest default for AI-powered development ✅ Why runtime injection beats local secret management ✅ How to demonstrate least privilege using read-only access and per-environment targeting ✅ How developer speed and enterprise governance can operate as the same workflow, not a tradeoff Register: https://bit.ly/4c1NviK #AI #DevSecOps #Cybersecurity #DeveloperTools

1

Coding agents are not replacing engineers. But if your skillset currently is "I write React", you need to step up. We need software engineers who can navigate business requests through the technical swamp. We don't need coders. Typing syntax is for robots, solving problems for engineers.

61

20 Comments

pro tip: teach your coding agent to make small commits. add pre-commit hooks in the same way you used conventional commits. pretty rad.

1

How to write the best prompts for a coding AGENT: Pair with another HUMAN on understanding and describing the problem. Still the same as before.

6

Everyone reaches for Redis or Kafka the moment they need real-time. But what if you didn’t have to? I’m not anti-Redis. I’m not anti-Kafka. I’m anti-“add another distributed system because we’re nervous.” I’ve seen teams spin up a broker cluster before they even had a throughput problem… then spend a year wrestling with its operational quirks, while their database sat underused, doing a fraction of the work it was already capable of. So I built a chat system that does the hard stuff: multi-node real-time delivery, per-room ordering, presence, typing indicators—using Postgres as both the source of truth and the real-time message bus. No brokers. No Redis. No RabbitMQ. No separate pub/sub. Just Postgres, NestJS, and raw WebSockets. Link in comment below ⬇️

12

1 Comment

Senior engineers get dozens of referral requests every week. Your inbox fills up. Your DMs overflow. Everyone wants that warm intro. But you're shipping code, leading teams, solving problems that matter. You want to help your network, but managing referrals feels like another full-time job. What if those referrals could actually pay you? Twill turns your professional network into an asset. Members are vetted professionals who know exactly who'd thrive in which role. When you refer someone through Twill, you earn up $5K. Think about it. You already know who the best engineers are. You've worked with them. You've seen them ship under pressure. Your recommendation carries weight because it's based on real experience, not a resume scan. The people using Twill are senior engineers, product leaders, and technical managers who understand that warm intros beat cold outreach every time. Your friends get better opportunities. Companies get pre-vetted talent. You get compensated for the value you're already creating. Stop letting referral requests drain your time. Start making them work for you.

10

1 Comment

We just released Taro's newest course about what life is really like at FAANG. So much of the discussion about working at FAANG focuses on things like the scale of the work or the free snacks. But on the day-to-day level, an engineer at Google or Facebook doesn't think about these topics. They are spending most of their waking hours on things like: - how much scope do they have? - how much control do they have vs just being a cog in the machine - what do their coworkers think about them? As a 5 year veteran of Meta, I break down the real pros and cons of working in Big Tech. Check it out here: https://lnkd.in/gfkwVDf9

58

4 Comments