Manuel Bogner’s Post

4% of all public GitHub commits are now written by Claude Code. 90% of Anthropic's own code is AI-written. But most engineers are still using it like a fancy autocomplete. I put together the power user guide I wish existed when I started. → The 5 core systems that separate 10x usage from expensive autocomplete → CLAUDE.md has a ~150 instruction budget before compliance drops. Most people blow past it. → Hooks are deterministic (100% execution). CLAUDE.md is advisory (~80%). Know which to use when. → Session forking: pre-warm a master session with 40K tokens of context, then fork per feature → Git worktrees for parallel agents without race conditions → MCP Tool Search saves 95% of your context window → Multi-agent orchestration patterns (tmux, containers, phone-based remote control) → Search tool decision tree: rg (20ms) → Serena (100ms) → ast-grep (200ms) → grepai (500ms) Sources: Anthropic official docs, awesome-claude-code, Trigger.dev, Builder.io, ykdojo/claude-code-tips, Cuttlesoft. Save this for your next deep session. ↓ What's the one Claude Code trick that changed your workflow the most? #ClaudeCode #AIEngineering #DevTools #AgenticCoding

The Claude Code Meetup runs every Wednesday at 1 PM Eastern inside the free Skool community. The format is live debugging, agent pattern review, and skill building with other developers who are actively shipping systems with Claude Code. A typical session looks like this: someone brings a real problem from their codebase, the group works through it on screen, and everyone walks out with a pattern they can use the same day. Recent topics have included MCP server configuration for Xano backends, skill file architecture for multi-agent systems, and the tmux setup for running agents from a phone. The problems are real, the repos are real, and the solutions ship that week. The meetup exists because the gap between knowing Claude Code exists and actually building production systems with it is not a documentation problem. It is a pattern problem. Developers need to see how other builders structure their skills, handle agent failures, and decide when to trust an agent with a long-running task. Reading docs gives you syntax; watching someone debug a broken agent loop live gives you judgment. The meetup is free, no pitch, no upsell. It sits alongside the Claude Code Mastery course, which covers the same material in structured, self-paced form. Both live inside skool.com/snappy. What agent pattern are you currently trying to figure out?

Introducing 'feature-inventory', the fourth skill in my open sourced skills repo. In a nutshell - It smartly catalogs every feature of your product in one structured YAML file - routes, endpoints, docs, flags - everything tied together. No matter what tech stack you have - it serves as the single source of truth. And it can then be scheduled to run on its own (claude/codex/cron - anything works), where it analyzes your codebase and updates the inventory on its own. Like all other skills I've been sharing, this too was born purely out of my own need and has been a critical component of my agent harness for last 3-4 months. Once you have features documented this way, you can basically attach any information to them - test coverage, help docs page, feature flag, frontend route, user persona for which it's enabled.. and much more. The end of the video shows the output for my project which has around 40-50 distinct features now. Give it a try and let me know if its helpful to you. Link in the first comment.

Technical tutorials build trust by solving real problems with code examples. Draft.dev creates step-by-step guides with the 'why' and 'how,' helping developers adopt your tech and drive awareness. Learn more: https://lnkd.in/gQksUyhk

Why did we build it this way again? If you manage an engineering team, you’ve probably heard this question a hundred times when looking at a 6-month-old codebase. The code tells you what happened. But the Pull Request description is the only place that tells you why. Tragically, the moment a PR gets merged, all that brilliant architectural context, decision-making, and trade-off analysis gets buried deep in a closed GitHub tab. When the time comes to refactor or onboard a new developer, that context is completely gone. Documentation is always an afterthought. [The Solution] I decided to fix this. Today, I'm incredibly excited to announce the launch of WhyLog. WhyLog is an AI-powered platform that automatically turns your chaotic GitHub merges into a beautifully organized, searchable knowledge base. [How it works] Here is how we are killing manual engineering documentation: Passive Capture: It listens to your GitHub webhooks. When a PR is merged, it extracts the underlying architectural decision. 💬 Slack Integration: It drafts a summary and drops it into your engineering Slack channel for a 1-click human approval.  The "Ask Why" Engine: It vectorizes the approved decision. Now, your team can simply ask our AI, "Why did we switch to bcrypt?" and get an instant answer linked directly to the original PR. No more lost context. No more writing separate documentation tickets. If you are an Engineering Manager or Tech Lead tired of losing your team's context, I would love for you to try it out. Check it out here: https://lnkd.in/d49CVX_x (If you want a personal onboarding session, shoot me a DM!)

I'm all-in with Claude Code to write most of my code. Using it to review that same code always felt wrong. Yes, GitHub Copilot has a review feature & Claude Code can comment on a PR too via their App. I've also set up the Cursor CLI inside a GHA workflow to make reviews with different models. But those are all tools doing a reviewer's job on the side and I didn't manage to get really good results, regardless of the efforts on the system prompt / instructions - probably a layer 8 problem, not gonna argue here. What's working for me finally... using a dedicated tool. CodeRabbit was built for exactly one thing and it does a MUCH better job that everything I've tried before. And now it lives in my terminal too. Their CLI can review your staged changes before you commit & not after you created the PR. The two things I like most: 1) It works with Claude Code directly. When it flags something, you hand it off to Claude to fix in one command. 2) Reviews happen locally before the "remote cycle" begins. If you prefer the IDE, the VS Code extension (also works in Cursor obviously) does the same thing (it's also free). Both are free and come with generous rate limits! https://fandf.co/48la8fA This post was created in collaboration with CodeRabbit, but it's a genuine recommendation after weeks of usage! 💛

Most developers don’t struggle because of skill. They struggle because they don’t ship. You don’t need: – another course – another tutorial – another “perfect stack” You need to finish something. Messy code > no product Shipped product > perfect repo Shipping is the real flex.

How to write a great README for a software project: Most READMEs are either empty or a dumping ground. Here's what a useful one contains: 📋 What does this project do? (2 sentences max) 🔧 Prerequisites — what you need before installing ⚡ Quick start — how to run it locally in under 5 commands 🏗 Architecture overview — how the main components fit together 🌍 Environment variables — a .env.example file, documented 🧪 How to run the tests 🚀 How to deploy to production 📞 Who to contact if something breaks The README is a love letter to your future self and everyone who comes after you. Write it like you'll need it at 3am six months from now. (You will.) #Documentation #GitHub #SoftwareDev #BestPractices #WebDev

I used to spend a decent chunk of my week doing the same thing over and over. Open GitHub. Find an issue. Spin up a branch. Write the code. Open a PR. Wait for CI. Merge. Close the issue. Delete the branch. Repeat. It felt productive. It wasn't. It was just motion. So I built something different. Now I open GitHub on Monday morning and there are already 30 new PRs waiting for review — written overnight by AI agents that read the issue backlog, picked up the work, and shipped it. Each one scoped to a single issue. Each one with tests. Each one with a proper commit message. I didn't write a single line of boilerplate. I reviewed the decisions that actually mattered. The thing nobody tells you about autonomous agent pipelines is that the hard part isn't the AI. It's the plumbing. Knowing which issues are ready to be picked up. Knowing which agent is cheap enough for a 5-line YAML fix vs. which one needs to reason about architecture. Knowing how to decompose a big epic into atomic slices that a model can actually finish in one shot. Once that's working, you stop being a code writer and start being a code reviewer. And honestly? That's the job I always wanted. If you're still manually triaging issues, writing boilerplate PRs, and cleaning up branches — there's a better way. Happy to talk about what that looks like. #AI #SoftwareEngineering #DeveloperProductivity #Automation #AgentWorkflows https://lnkd.in/eHXzFDuC

Stacked pull requests are what happens when a code review workflow finally admits how little reviewer bandwidth we actually have. For years, a lot of teams treated giant PRs like a character test. If your coworkers loved you enough, surely they would review 1,200 lines of refactors, feature code, renames, and one suspicious config change hiding near the bottom. Then everyone acted surprised when pull request review turned into archaeology. That is why GitHub Stacked PRs feels important. Not because it is flashy. Because it quietly acknowledges the real bottleneck in developer productivity: review attention. Most teams do not need more code generation. They need smaller diffs, clearer sequencing, and a saner code review workflow where reviewers can approve intent one layer at a time instead of reverse-engineering the whole novel. The useful part of stacked pull requests is not elegance. It is mercy. Better pull request review means less context loss, fewer “can you rebase again?” rituals, and a lower chance that the risky change ships bundled with six unrelated ones. Software teams love talking about velocity. Stacked pull requests are a reminder that shipping speed is often limited by how easy you make it for another tired engineer to say yes. Would stacked pull requests actually improve your team’s workflow, or would your repo habits fight the idea? #StackedPullRequests #CodeReview #GitHub #DeveloperProductivity #DevEx #PullRequests #SoftwareEngineering