Baz’s Post

Stop reviewing lines of code. Start reviewing impact. At Baz, code review has always been at the core. Our agent can spot bugs, question naming, suggest cleaner patterns, identify duplication and more. What we couldn’t always measure was impact - what changes after this PR, and how it measures against the ticket and design. That’s changing. Over the past few weeks we’ve been building an AI reviewer that first understands why the code change was even implemented. It reads the code diff, the Atlassian Jira ticket and spec, the Figma design and helps reviewers understand where this code change fits, and whether it actually delivers on what was promised. It’s already reshaping how we work. Conversations in reviews have shifted from “does this function handle nulls?” to “What about this case?”. To make that possible we had the cultural obstacle of aligning specs, tickets, and designs. Not easy for a startup to do. But take the example below - we implemented a new integration page, and before I reviewed a single line of code I can read the comment and understand what exactly to expect in the product. Leveraging Amazon Web Services (AWS)'s new Bedrock AgentCore and Playwright MCP, we were able to actually bring our web UI alive and test it for real! And it’s bringing us one step closer to code reviews that focus not just on what changed but why it matters. Great job Osher Maayan Omri Levy Nimrod Hauser Yarden Mintz and Shachar Azriel!!

Want to get to first commit on day1 of the new project? Get thoroughly bored by documenting your own code? Hate to spend long hours understanding new libraries , and code repos? Feel frustrated when you lose time trying to find the right file for deep diving ? Take a look at code wiki. Google built a system that fulfills this mission by keeping documentation alive. Instead of static files, it maintains a continuously updated, structured wiki for every repository. Automated & always up-to-date: Code Wiki scans the full codebase and regenerates the documentation after each change. The docs evolve with the code. Intelligent & context-aware: The entire, always-current wiki serves as the knowledge base for an integrated chat. You’re not talking to a generic model, but to one that knows your repo end-to-end. Integrated & actionable: Every wiki section and chat answer is hyper-linked directly to the relevant code files and definitions. Reading and exploring merge into one workflow https://lnkd.in/dKyGXamd #devops #vibecoding #devproductivity

A dev just shared six months of using Claude Code on a 300k-line refactor - and his post broke Reddit. Here are three takeaways that’ll change how you think about coding agents 1. Manage context like your sanity depends on it. Because it does. Break context into small, consistent chunks and control which snippets load each time. If your context isn’t specific enough, the agent will ignore your standards. If irrelevant guidelines are injected, you’ll get context dilution - and hallucinations will skyrocket. 2. Stop hoping agents will remember - build enforcement. Claude Code uses hooks: deterministic code wrapped around the agent’s non-deterministic flow. Use them to inject standards before generation and check output after. Don’t allow agents drift from your guidelines - it’s solvable. Newer models won’t fix bad discipline. 3. Give agents debugging tools - and hold them accountable. Let them see the results of their actions. Be clear about your expectations. Provide visibility into logs, tests, and monitoring data so they can flag errors and propose fixes. The pattern behind all three: The ceiling everyone hits with coding agents is mostly imaginary - it’s not about model limits, it’s about missing system. Coding agents, like teammates, need process, observability, and feedback loops to be effective. So stop adjusting your expectations and workflows to your agents’ behavior, and start adjusting your agents to your expectations. We’re in the early days of devops for our AI companions, but these are the foundations of the next generation of engineering. Links to the full post and example hooks are in the comments.

We're all acknowledging that 𝗰𝗼𝗱𝗲 𝗿𝗲𝘃𝗶𝗲𝘄 𝗵𝗮𝘀 𝗯𝗲𝗰𝗼𝗺𝗲 𝗮𝗻 𝗶𝗻𝗰𝗿𝗲𝗮𝘀𝗶𝗻𝗴𝗹𝘆 𝗰𝗿𝗶𝘁𝗶𝗰𝗮𝗹 𝘀𝘁𝗲𝗽 in software engineering at this point in time. Even teams that were less accustomed to it are now adopting the practice, with benefits that go beyond the changes brought by AI. I believe the 𝗰𝘂𝗿𝗿𝗲𝗻𝘁 𝗰𝗼𝗱𝗲 𝗿𝗲𝘃𝗶𝗲𝘄 𝗲𝘅𝗽𝗲𝗿𝗶𝗲𝗻𝗰𝗲 𝗵𝗮𝘀 𝘁𝗿𝗲𝗺𝗲𝗻𝗱𝗼𝘂𝘀 𝗿𝗼𝗼𝗺 𝗳𝗼𝗿 𝗶𝗺𝗽𝗿𝗼𝘃𝗲𝗺𝗲𝗻𝘁, especially now that it's becoming a strategic activity. Reviews today typically happen on the Git Provider's web portal, through iterations of contextual comments on code changes. Anyone doing them regularly will agree it's a complex activity, because understanding code is far harder than writing it. Often a review requires many asynchronous iterations and constant context switching. In my view, the main areas for improvement are: 💡 The ability to run the code under review in an 𝗲𝗽𝗵𝗲𝗺𝗲𝗿𝗮𝗹 𝘀𝗮𝗻𝗱𝗯𝗼𝘅, spun up automatically. 💡 Enabling modifications to be written with the 𝘀𝗮𝗺𝗲 𝗜𝗗𝗘 𝗲𝘅𝗽𝗲𝗿𝗶𝗲𝗻𝗰𝗲, including type checking, code completion, code navigation, linting, and formatting 💡 The possibility of having more context within the Pull/Merge Request: requirements imported from task management systems, acceptance criteria, feedback from the QA team 💡 Smarter notification mechanisms (in-app), as today we typically rely on email 💡 Prioritization mechanisms that draw attention (through AI analysis) to the most critical parts 💡 Workflows that facilitate 𝗰𝗼𝗹𝗹𝗮𝗯𝗼𝗿𝗮𝘁𝗶𝘃𝗲 𝗿𝗲𝘃𝗶𝗲𝘄𝘀, where different team members focus on different aspects: functionality, security, performance, design, etc. 💡 Integration with messaging systems to schedule automatic follow-ups between requesters and reviewers GitHub, GitLab, Atlassian Bitbucket - the ball's in your court!

💡 In code, deleting is as important as adding. We often get excited about adding new features, writing new functions, or pushing shiny updates — but rarely about removing what’s no longer needed. Yet, deleting that unused variable, that redundant custom function, or that out-of-scope feature can save hours — sometimes days — for the next developer who takes over your project. Clean code isn’t just about readability — it’s about respecting the next person who will maintain it. They shouldn’t have to decode why a dead piece of code still exists. And when they see your organized, lean commits — they’ll silently thank you (instead of cursing your name 😅). Every time you refactor, simplify, or delete what’s unnecessary — you’re not just improving the codebase.You’re improving your craft. Because as they say — “You know you’re growing as a developer when you start to hate the code you wrote a year ago.” Keep building. Keep deleting. Keep refining. Follow Daniyaal Saifee Nayeem for more.

Google just launched Code Wiki in public preview on November 13, 2025—a smart, AI-driven platform that automatically generates and maintains up-to-date documentation for code repositories. https://lnkd.in/ecnypf6h

🚀 Releasing : Nice Specs – An open-source VS Code extension for Documentation-First Architecture for Your Codebase. No servers, no third party risk, local stores for keyword and contextual search. It uses code agents you installed in VS Code and already paid for. No extra cost of hosting LLM. With Coding Agents becoming the de-facto tool for coding, it is important to control the hallucination as well as make it easier for reviewers to go through large PRs. Also, it is essential to document code components to give better context to code agents for future iteration in code. Nice Specs creates documentation from the source, keeps it in the repo, and makes it incrementally maintainable. If you’re working with large codebases, onboarding new contributors, and working with code agents — this may help. 🔗 Check It Out here https://lnkd.in/gnBEmEFt ⭐ What Nice Specs Does It introduces a new doc-focused agent (@nicespecs) that generates folder-level architecture docs, component relationships, and root-level system overviews using your actual code as the source of truth. A few highlights: Documentation Guardrails: It only responds to documentation-related prompts, keeping it focused and predictable. Smart Workspace Traversal: Understands your project structure, skips noise, and organizes the codebase into “components.” Automatic Markdown Specs: Produces clean nicespecs.*.md files inside each folder, co-located with the code they describe. Parent/Child Architecture Summaries: Builds a living component tree across the repo. Incremental Updates: Only regenerates docs for changed components, saving tokens, time, and attention. Resilience & Transparency: Resume mid-run, track progress, estimate token cost before executing. All of this is built with readability in mind — for both humans and AI agents. Open for critique, feedback and collaboration on this. This is just an initial phase for making a transition towards documentation based LLM driven software development and maintenance. Lot can be done in this. On top of this, lot of other use cases can be made in the area of code reviews and automation testing for components.

Finding answers in your codebase should feel as natural as asking a teammate – and with CodeQA, it does. Instead of digging through repositories, your team simply asks a question, and gets precise, context-rich answers in seconds. That’s the difference between traditional search and CodeQA. While traditional search stops at keywords and returns links, CodeQA understands intent and delivers answers. It reads your codebase and past discussions like a senior engineer, giving you context-rich, evidence-based results. ✅ CodeQA → Understands context ❌ Traditional Search → Looks for matching keywords ✅ CodeQA → Delivers real answers ❌ Traditional Search → Returns links ✅ CodeQA → Guides you to best practices ❌ Traditional Search → Can’t interpret intent The result? Instant clarity. Faster delivery. Smarter collaboration. Empower your team to find answers, not just links. 👉 See CodeQA in action. Book a quick demo today: https://www.codeqa.ai/ 

Balancing trunk-based development with the need for controlled user testing in a staging environment can be a tricky process. I recently gave our release workflow a complete overhaul to solve this, and we've successfully moved over to using Google's release-please to drive the automation. I've written an article detailing the full journey, from the initial challenge to the automated solution. I hope you find it a useful read! https://lnkd.in/eS2RuFQc

From Copy-Paste to Smart Code Let’s be real — most of us began our journey in software development by copying and pasting code. From StackOverflow snippets to GitHub gists, we’ve all done it. And now, in the era of AI-generated solutions, it’s even more common. Hardly anyone writes everything from scratch anymore — and that’s okay. Even management (directly or indirectly) supports this culture by not allowing enough time for exploration, optimization, and clean coding in the delivery cycle. But the real question is — Are we growing as engineers if all we do is copy and run? Short answer: No — not really. Copying helps you get things done, but it rarely helps you understand things deeply.Real growth as an engineer comes from knowing why something works — not just that it works. That’s what differentiates a coder from a developer — and a developer from an engineer. Why writing optimized and correct code truly matters: 1. Fewer Bugs & Production Issues When you understand the logic behind what you’re implementing, you avoid hidden pitfalls early. This leads to more stable releases, fewer hotfixes, and a more reliable product experience. 2. Better Performance & Efficiency Optimized code reduces unnecessary computations and resource usage — resulting in faster performance, smoother user experiences, and scalable systems. 3. Easier Maintenance & Future Enhancements Readable, modular, and well-documented code allows your future self (or your teammates) to make improvements confidently, without breaking existing functionality. 4. Strong Debugging & Problem-Solving Skills When you know why your code works, debugging stops being guesswork. You can identify and fix issues faster, leading to higher overall productivity. 5. Career Growth & Technical Credibility Writing smart, optimized, and maintainable code builds your professional reputation. It’s the difference between a developer who delivers features and an engineer who designs sustainable systems.