{"exhaustive":{"nbHits":false,"typo":false},"exhaustiveNbHits":false,"exhaustiveTypo":false,"hits":[{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"fforbeck"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["code","review","ai","generated","bottleneck"],"value":"Hey, you probably already saw that reviewing <em>AI</em>-<em>generated</em> <em>code</em> is a nightmare and quickly becomes a <em>bottleneck</em>. Everyone is using <em>AI</em> agents to write <em>code</em> fast, but the hard part is reviewing a bazillion lines.<p>I was thinking about building something that would guide me during development and during PR reviews. Something that would give me signals based on facts, risks, and evidence. Not just one LLM reviewing the <em>code</em> it <em>generated</em>. The initial idea was to add a deterministic <em>review</em> layer and combine that with LLM reasoning, and use that to find gaps in <em>code</em> and point me to the most important places, so I don't need to read line by line.<p>I ended up building a tool called vdiff, and it is working very well for me, and I'm constantly improving it. It is a CLI that analyzes your git diffs and gives you a structured report: what changed, what's risky, and what's missing. It uses tree-sitter for AST diffs and an LLM on top, so you get actual evidence for each finding, not just vibes.<p>Some of the output signals:\n- Tells you if it's safe to merge, with a risk score\n- Lists what's wrong, how confident it is, and shows the evidence\n- Dependency graph for blast radius analysis\n- <em>Review</em> memory (tracks resolved/reopened findings across sessions)\n- You can point it at a spec or PRD, and it checks if the changes actually match\n- Structural metrics (acyclicity, depth, equality, graph)<p>It runs locally; I didn't want the tool publishing the <em>code</em> to a third-party server, so your <em>code</em> never leaves your machine. BYOK (bring your own LLM key) - you interact directly with the provider.<p>If you want to give it a try:<p><pre><code>  npm i -g @4bk/vdiff     # install globally\n  pip install graphifyy   # required to generate the knowledge graph\n  cd your-project         # go to a git repo\n  vdiff init              # set up provider, API key, build knowledge graph\n  vdiff -v                # analyze staged changes\n</code></pre>\nWould love to hear if this is something helpful for you as well, and what kind of signals you'd want to see. I usually run it before each commit on a feature branch, and then on CI to verify the feature branch against main.<p>Any feedback is very welcome, and if it is crap, well, then just say it.<p>Cheers"},"title":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["code","review","ai","generated"],"value":"Show HN: Vdiff \u2013 CLI to help you <em>review</em> <em>AI</em>-<em>generated</em> <em>code</em>"}},"_tags":["story","author_fforbeck","story_47986749","show_hn"],"author":"fforbeck","created_at":"2026-05-02T14:35:21Z","created_at_i":1777732521,"num_comments":0,"objectID":"47986749","points":1,"story_id":47986749,"story_text":"Hey, you probably already saw that reviewing AI-generated code is a nightmare and quickly becomes a bottleneck. Everyone is using AI agents to write code fast, but the hard part is reviewing a bazillion lines.<p>I was thinking about building something that would guide me during development and during PR reviews. Something that would give me signals based on facts, risks, and evidence. Not just one LLM reviewing the code it generated. The initial idea was to add a deterministic review layer and combine that with LLM reasoning, and use that to find gaps in code and point me to the most important places, so I don&#x27;t need to read line by line.<p>I ended up building a tool called vdiff, and it is working very well for me, and I&#x27;m constantly improving it. It is a CLI that analyzes your git diffs and gives you a structured report: what changed, what&#x27;s risky, and what&#x27;s missing. It uses tree-sitter for AST diffs and an LLM on top, so you get actual evidence for each finding, not just vibes.<p>Some of the output signals:\n- Tells you if it&#x27;s safe to merge, with a risk score\n- Lists what&#x27;s wrong, how confident it is, and shows the evidence\n- Dependency graph for blast radius analysis\n- Review memory (tracks resolved&#x2F;reopened findings across sessions)\n- You can point it at a spec or PRD, and it checks if the changes actually match\n- Structural metrics (acyclicity, depth, equality, graph)<p>It runs locally; I didn&#x27;t want the tool publishing the code to a third-party server, so your code never leaves your machine. BYOK (bring your own LLM key) - you interact directly with the provider.<p>If you want to give it a try:<p><pre><code>  npm i -g @4bk&#x2F;vdiff     # install globally\n  pip install graphifyy   # required to generate the knowledge graph\n  cd your-project         # go to a git repo\n  vdiff init              # set up provider, API key, build knowledge graph\n  vdiff -v                # analyze staged changes\n</code></pre>\nWould love to hear if this is something helpful for you as well, and what kind of signals you&#x27;d want to see. I usually run it before each commit on a feature branch, and then on CI to verify the feature branch against main.<p>Any feedback is very welcome, and if it is crap, well, then just say it.<p>Cheers","title":"Show HN: Vdiff \u2013 CLI to help you review AI-generated code","updated_at":"2026-05-02T14:36:43Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"flamestro"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["code","review","ai","generated","bottleneck"],"value":"I built Deff because <em>AI</em> coding tools sped up writing <em>code</em>, but reviewing their changes became the new <em>bottleneck</em>.  \nMost of my time was going into checking noisy diffs, understanding intent, and making sure nothing subtle broke.\nDeff is focused on one thing: helping you <em>review</em> <em>AI</em>-<em>generated</em> <em>code</em> changes faster and with more confidence.  \nIt helps surface what changed and is allowing me to use it with some vim motions so I can easily jump from nvim to opencode to deff.\nWould love feedback from people using <em>AI</em> coding assistants heavily \u2014 especially on <em>review</em> workflows, false positives, and what still feels slow."},"title":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["code","review","ai","generated"],"value":"Show HN: Deff \u2013 <em>Review</em> <em>AI</em>-<em>generated</em> <em>code</em> changes"},"url":{"matchLevel":"none","matchedWords":[],"value":"https://github.com/flamestro/deff"}},"_tags":["story","author_flamestro","story_47159700","show_hn"],"author":"flamestro","created_at":"2026-02-25T23:43:32Z","created_at_i":1772063012,"num_comments":0,"objectID":"47159700","points":1,"story_id":47159700,"story_text":"I built Deff because AI coding tools sped up writing code, but reviewing their changes became the new bottleneck.  \nMost of my time was going into checking noisy diffs, understanding intent, and making sure nothing subtle broke.\nDeff is focused on one thing: helping you review AI-generated code changes faster and with more confidence.  \nIt helps surface what changed and is allowing me to use it with some vim motions so I can easily jump from nvim to opencode to deff.\nWould love feedback from people using AI coding assistants heavily \u2014 especially on review workflows, false positives, and what still feels slow.","title":"Show HN: Deff \u2013 Review AI-generated code changes","updated_at":"2026-03-05T23:37:29Z","url":"https://github.com/flamestro/deff"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"vinitmaniar"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["code","review","ai","generated","bottleneck"],"value":"Hi everyone,<p>Over the past few months, we\u2019ve been building Everdone \u2014 an <em>AI</em>-powered engineering workflow platform.<p>We initially launched with:\n- CodeDoc (<em>AI</em>-<em>generated</em> <em>code</em> documentation)\n- <em>CodeReview</em> (structured issue detection + tracking)<p>Today we\u2019ve added two more services:\n- CodeSecurity \u2014 iterative application security <em>review</em>\n- CodePerformance \u2014 structured performance improvement workflow<p>Why we built CodeSecurity\nMost security tools generate a report and stop there.<p>In practice, teams:\n- Fix a few issues\n- Forget the rest\n- Don\u2019t re-verify properly<p>We designed CodeSecurity as an iterative loop instead of a one-off scan:\n- Connect GitHub\n- Select a PR or branch\n- <em>AI</em> reviews for real, exploitable vulnerabilities\n- Engineers fix\n- Re-run \u2192 <em>AI</em> verifies whether issues are actually resolved<p>Issues are tracked with:\n- Severity (High/Medium/Low)\n- File + line numbers\n- Concrete suggested fixes\n- Status workflow (Open \u2192 In Progress \u2192 Resolved \u2192 Closed/Rejected)\n- Full verification history<p>It behaves more like a managed security workflow than a static analyzer.<p>Why we built CodePerformance\nPerformance reviews often happen reactively (after something slows down in prod).<p>CodePerformance focuses on material runtime impact:\n- Algorithmic inefficiencies\n- N+1 queries\n- Blocking I/O\n- Memory pressure\n- Concurrency <em>bottlenecks</em>\n- Event-loop blocking (Node), GIL issues (Python), etc.<p>Same loop:\nFind \u2192 Fix \u2192 Re-run \u2192 Verified.<p>Current platform\nEverdone now includes:\n- CodeDoc\n- <em>CodeReview</em>\n- CodeSecurity\n- CodePerformance<p>Pricing:\n- First 200 files free\n- $0.05 per file per <em>review</em> (early access pricing)\n- Unlimited users\n- No contracts<p>Usage-based only.<p>We also have live demos on public OSS repos if anyone wants to explore without signing up.<p>We\u2019re trying to build \u201cWork as a Service\u201d \u2014 <em>AI</em> systems that fit into real engineering workflows rather than replacing them or generating static reports.<p>Would love feedback from other founders or engineering teams.<p>Happy to answer anything.<p>\u2014 Vinit"},"title":{"matchLevel":"none","matchedWords":[],"value":"Show HN: Everdone CodeSecurity and CodePerformance"},"url":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["ai"],"value":"https://everdone.<em>ai</em>/"}},"_tags":["story","author_vinitmaniar","story_47048259","show_hn"],"author":"vinitmaniar","created_at":"2026-02-17T15:05:20Z","created_at_i":1771340720,"num_comments":0,"objectID":"47048259","points":1,"story_id":47048259,"story_text":"Hi everyone,<p>Over the past few months, we\u2019ve been building Everdone \u2014 an AI-powered engineering workflow platform.<p>We initially launched with:\n- CodeDoc (AI-generated code documentation)\n- CodeReview (structured issue detection + tracking)<p>Today we\u2019ve added two more services:\n- CodeSecurity \u2014 iterative application security review\n- CodePerformance \u2014 structured performance improvement workflow<p>Why we built CodeSecurity\nMost security tools generate a report and stop there.<p>In practice, teams:\n- Fix a few issues\n- Forget the rest\n- Don\u2019t re-verify properly<p>We designed CodeSecurity as an iterative loop instead of a one-off scan:\n- Connect GitHub\n- Select a PR or branch\n- AI reviews for real, exploitable vulnerabilities\n- Engineers fix\n- Re-run \u2192 AI verifies whether issues are actually resolved<p>Issues are tracked with:\n- Severity (High&#x2F;Medium&#x2F;Low)\n- File + line numbers\n- Concrete suggested fixes\n- Status workflow (Open \u2192 In Progress \u2192 Resolved \u2192 Closed&#x2F;Rejected)\n- Full verification history<p>It behaves more like a managed security workflow than a static analyzer.<p>Why we built CodePerformance\nPerformance reviews often happen reactively (after something slows down in prod).<p>CodePerformance focuses on material runtime impact:\n- Algorithmic inefficiencies\n- N+1 queries\n- Blocking I&#x2F;O\n- Memory pressure\n- Concurrency bottlenecks\n- Event-loop blocking (Node), GIL issues (Python), etc.<p>Same loop:\nFind \u2192 Fix \u2192 Re-run \u2192 Verified.<p>Current platform\nEverdone now includes:\n- CodeDoc\n- CodeReview\n- CodeSecurity\n- CodePerformance<p>Pricing:\n- First 200 files free\n- $0.05 per file per review (early access pricing)\n- Unlimited users\n- No contracts<p>Usage-based only.<p>We also have live demos on public OSS repos if anyone wants to explore without signing up.<p>We\u2019re trying to build \u201cWork as a Service\u201d \u2014 AI systems that fit into real engineering workflows rather than replacing them or generating static reports.<p>Would love feedback from other founders or engineering teams.<p>Happy to answer anything.<p>\u2014 Vinit","title":"Show HN: Everdone CodeSecurity and CodePerformance","updated_at":"2026-03-05T23:34:25Z","url":"https://everdone.ai/"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"cpan22"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["code","review","ai","generated","bottleneck"],"value":"Hey HN! We're Charles and Dean, and we're building Stage: a <em>code</em> <em>review</em> tool that guides you through reading a PR step by step, instead of piecing together a giant diff.<p>Here's a demo video: <a href=\"https://www.tella.tv/video/stage-demo-1pph\" rel=\"nofollow\">https://www.tella.tv/video/stage-demo-1pph</a>.\nYou can play around with some example PRs here: <a href=\"https://stagereview.app/explore\">https://stagereview.app/explore</a>.<p>Teams are moving faster than ever with <em>AI</em> these days, but more and more engineers are merging changes that they don't really understand. The <em>bottleneck</em> isn't writing <em>code</em> anymore, it's reviewing it.<p>We're two engineers who got frustrated with GitHub's UI for <em>code</em> <em>review</em>. As coding agents took off, we saw our PR backlog pile up faster than we could handle. Not only that, the PRs themselves were getting larger and harder to understand, and we found ourselves spending most of our time trying to build a mental model of what a PR was actually doing.<p>We built Stage to make reviewing a PR feel more like reading chapters of a book, not an unorganized set of paragraphs. We use it every day now, not just to <em>review</em> each other's <em>code</em> but also our own, and at this point we can't really imagine going back to the old GitHub UI.<p>What Stage does: when a PR is opened, Stage groups the changes into small, logical &quot;chapters&quot;. These chapters get ordered in the way that makes most sense to read. For each chapter, Stage tells you what changed and specific things to double check. Once you <em>review</em> all the chapters, you're done reviewing the PR.<p>You can sign in to Stage with your GitHub account and everything is synced seamlessly (commenting, approving etc.) so it fits into the workflows you're already used to.<p>What we're not building: a <em>code</em> <em>review</em> bot like CodeRabbit or Greptile. These tools are great for catching bugs (and we use them ourselves!) but at the end of the day humans are responsible for what gets shipped. It's clear that reviewing <em>code</em> hasn't scaled the same way that writing did, and they (we!) need better tooling to keep up with the onslaught of <em>AI</em> <em>generated</em> <em>code</em>, which is only going to grow.<p>We've had a lot of fun building this and are excited to take it further. If you're like us and are also tired of using GitHub for reviewing PRs, we'd love for you to try it out and tell us what you think!"},"title":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["code","review"],"value":"Show HN: Stage \u2013 Putting humans back in control of <em>code</em> <em>review</em>"},"url":{"matchLevel":"none","matchedWords":[],"value":"https://stagereview.app/"}},"_tags":["story","author_cpan22","story_47796818","show_hn"],"author":"cpan22","children":[47796999,47797132,47799555,47799945,47804322,47806067,47806199,47806213,47806402,47806409,47806476,47806648,47806895,47806971,47807104,47807461,47807516,47807649,47807771,47808445,47808773,47808797,47809102,47809438,47809762,47809770,47810214,47810343,47810733,47810873,47811529,47812258,47812408,47812764,47813475,47815808,47826031,47835842,47903326],"created_at":"2026-04-16T17:36:29Z","created_at_i":1776360989,"num_comments":111,"objectID":"47796818","points":130,"story_id":47796818,"story_text":"Hey HN! We&#x27;re Charles and Dean, and we&#x27;re building Stage: a code review tool that guides you through reading a PR step by step, instead of piecing together a giant diff.<p>Here&#x27;s a demo video: <a href=\"https:&#x2F;&#x2F;www.tella.tv&#x2F;video&#x2F;stage-demo-1pph\" rel=\"nofollow\">https:&#x2F;&#x2F;www.tella.tv&#x2F;video&#x2F;stage-demo-1pph</a>.\nYou can play around with some example PRs here: <a href=\"https:&#x2F;&#x2F;stagereview.app&#x2F;explore\">https:&#x2F;&#x2F;stagereview.app&#x2F;explore</a>.<p>Teams are moving faster than ever with AI these days, but more and more engineers are merging changes that they don&#x27;t really understand. The bottleneck isn&#x27;t writing code anymore, it&#x27;s reviewing it.<p>We&#x27;re two engineers who got frustrated with GitHub&#x27;s UI for code review. As coding agents took off, we saw our PR backlog pile up faster than we could handle. Not only that, the PRs themselves were getting larger and harder to understand, and we found ourselves spending most of our time trying to build a mental model of what a PR was actually doing.<p>We built Stage to make reviewing a PR feel more like reading chapters of a book, not an unorganized set of paragraphs. We use it every day now, not just to review each other&#x27;s code but also our own, and at this point we can&#x27;t really imagine going back to the old GitHub UI.<p>What Stage does: when a PR is opened, Stage groups the changes into small, logical &quot;chapters&quot;. These chapters get ordered in the way that makes most sense to read. For each chapter, Stage tells you what changed and specific things to double check. Once you review all the chapters, you&#x27;re done reviewing the PR.<p>You can sign in to Stage with your GitHub account and everything is synced seamlessly (commenting, approving etc.) so it fits into the workflows you&#x27;re already used to.<p>What we&#x27;re not building: a code review bot like CodeRabbit or Greptile. These tools are great for catching bugs (and we use them ourselves!) but at the end of the day humans are responsible for what gets shipped. It&#x27;s clear that reviewing code hasn&#x27;t scaled the same way that writing did, and they (we!) need better tooling to keep up with the onslaught of AI generated code, which is only going to grow.<p>We&#x27;ve had a lot of fun building this and are excited to take it further. If you&#x27;re like us and are also tired of using GitHub for reviewing PRs, we&#x27;d love for you to try it out and tell us what you think!","title":"Show HN: Stage \u2013 Putting humans back in control of code review","updated_at":"2026-11-12T07:01:15Z","url":"https://stagereview.app/"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"othmanosx"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["code","review","ai","generated","bottleneck"],"value":"With the introduction of <em>AI</em> into our workflow, we started using it in many different ways, and we took different paths in how we use it for sowftware engineering.<p>Stage, treated <em>AI</em> as a tool to chapter a PR into different sections to make reviewing a large PR easier by chunking it into chapters with <em>AI</em> <em>generated</em> summaries, they realized that <em>code</em> <em>review</em> is the <em>bottleneck</em> now, but their take on how <em>AI</em> can improve or speed up a PR <em>review</em> is incorrect from my perspective.<p>Adding more <em>AI</em> <em>generated</em> stuff to an already large <em>AI</em>-<em>generated</em> <em>code</em> just makes the <em>review</em> slower and more daunting. but their product inspired me to do it the right way.<p>Meet Pyor! (pyor.<em>review</em>)\nPyor's goal is to use <em>AI</em> to reduce the amount of <em>code</em> required to <em>review</em>, not increase it.<p>Unlike GitHub, Pyor lists <em>code</em> changes in a chronological order for\nfaster and easier <em>review</em> that's linear to avoid context switching, it\nalso uses <em>AI</em> to group the mechanical noise in a PR so a reviewer skims it and spends real attention only on the changes that matter.<p>we built Pyor by engineers to help engineers move faster in the <em>AI</em> era, and that's our bet."},"title":{"matchLevel":"none","matchedWords":[],"value":"Show HN: Stage is sunestting their product, what now?"}},"_tags":["story","author_othmanosx","story_48996894","show_hn"],"author":"othmanosx","created_at":"2026-07-21T19:20:06Z","created_at_i":1784661606,"num_comments":0,"objectID":"48996894","points":2,"story_id":48996894,"story_text":"With the introduction of AI into our workflow, we started using it in many different ways, and we took different paths in how we use it for sowftware engineering.<p>Stage, treated AI as a tool to chapter a PR into different sections to make reviewing a large PR easier by chunking it into chapters with AI generated summaries, they realized that code review is the bottleneck now, but their take on how AI can improve or speed up a PR review is incorrect from my perspective.<p>Adding more AI generated stuff to an already large AI-generated code just makes the review slower and more daunting. but their product inspired me to do it the right way.<p>Meet Pyor! (pyor.review)\nPyor&#x27;s goal is to use AI to reduce the amount of code required to review, not increase it.<p>Unlike GitHub, Pyor lists code changes in a chronological order for\nfaster and easier review that&#x27;s linear to avoid context switching, it\nalso uses AI to group the mechanical noise in a PR so a reviewer skims it and spends real attention only on the changes that matter.<p>we built Pyor by engineers to help engineers move faster in the AI era, and that&#x27;s our bet.","title":"Show HN: Stage is sunestting their product, what now?","updated_at":"2026-07-22T01:42:58Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"aswinzzz"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["code","review","ai","generated","bottleneck"],"value":"Hey HN!<p>I'm excited to share PullSense \u2013 an <em>AI</em>-powered tool that helps developers automate pull request <em>reviews</em> on GitHub. We're not here to replace human <em>reviews</em>\u2014PullSense acts as a first-pass reviewer to speed up the process and catch common issues before manual <em>review</em>. Think of it as an <em>AI</em> assistant that makes PR <em>reviews</em> more efficient, not as a replacement for human expertise.<p>Why I Built This<p>As a developer, I\u2019ve spent countless hours reviewing PRs\u2014many of which involve repetitive feedback on things like maintainability, best practices, and error handling. I wanted a tool that could speed up this process, provide actionable <em>AI</em>-<em>generated</em> feedback, and work seamlessly with GitHub.<p>How PullSense Works<p>1. Connect Your GitHub Repos \u2013 Add your API key for org or user-level access.<p>2. Select Repositories \u2013 Choose which repos to monitor.<p>3. <em>AI</em>-Powered <em>Reviews</em> \u2013 Comment pull-sense please <em>review</em> on any PR to trigger <em>AI</em> analysis.<p>4. Get <em>AI</em>-<em>Generated</em> Feedback \u2013 PullSense adds inline comments on PRs for potential bugs, security concerns, and refactoring suggestions.<p>5. Refine &amp; Merge Faster \u2013 Use <em>AI</em> insights to enhance <em>code</em> quality before the final human <em>review</em>.<p>Key Features<p>1. <em>AI</em>-Powered PR <em>Reviews</em> \u2013 Automatic feedback on GitHub PRs.<p>2. Bring Your Own Key (BYOK) \u2013 You control the <em>AI</em>! Use OpenAI or other <em>AI</em> providers with your own API key.<p>3. Seamless GitHub Integration \u2013 Works as a bot, no complex setup.<p>4. Customizable Rules \u2013 Fine-tune <em>AI</em> <em>review</em> behavior.<p>5. Privacy-Focused \u2013 No unnecessary data storage.<p>Who Is This For?<p>- Individual devs who want faster PR <em>reviews</em>.<p>- Teams &amp; startups looking to reduce <em>code</em> <em>review</em> <em>bottlenecks</em>.<p>- Open-source maintainers dealing with large volumes of PRs.<p>Try PullSense for Free @ PullSense.com<p>Would love to hear your thoughts, feedback, and ideas for improvements! Happy coding!"},"title":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["review","ai"],"value":"Show HN: PullSense \u2013 <em>AI</em>-Powered PR <em>Reviews</em> for GitHub"},"url":{"matchLevel":"none","matchedWords":[],"value":"https://www.pullsense.com/"}},"_tags":["story","author_aswinzzz","story_43048989","show_hn"],"author":"aswinzzz","created_at":"2025-02-14T15:00:33Z","created_at_i":1739545233,"num_comments":0,"objectID":"43048989","points":1,"story_id":43048989,"story_text":"Hey HN!<p>I&#x27;m excited to share PullSense \u2013 an AI-powered tool that helps developers automate pull request reviews on GitHub. We&#x27;re not here to replace human reviews\u2014PullSense acts as a first-pass reviewer to speed up the process and catch common issues before manual review. Think of it as an AI assistant that makes PR reviews more efficient, not as a replacement for human expertise.<p>Why I Built This<p>As a developer, I\u2019ve spent countless hours reviewing PRs\u2014many of which involve repetitive feedback on things like maintainability, best practices, and error handling. I wanted a tool that could speed up this process, provide actionable AI-generated feedback, and work seamlessly with GitHub.<p>How PullSense Works<p>1. Connect Your GitHub Repos \u2013 Add your API key for org or user-level access.<p>2. Select Repositories \u2013 Choose which repos to monitor.<p>3. AI-Powered Reviews \u2013 Comment pull-sense please review on any PR to trigger AI analysis.<p>4. Get AI-Generated Feedback \u2013 PullSense adds inline comments on PRs for potential bugs, security concerns, and refactoring suggestions.<p>5. Refine &amp; Merge Faster \u2013 Use AI insights to enhance code quality before the final human review.<p>Key Features<p>1. AI-Powered PR Reviews \u2013 Automatic feedback on GitHub PRs.<p>2. Bring Your Own Key (BYOK) \u2013 You control the AI! Use OpenAI or other AI providers with your own API key.<p>3. Seamless GitHub Integration \u2013 Works as a bot, no complex setup.<p>4. Customizable Rules \u2013 Fine-tune AI review behavior.<p>5. Privacy-Focused \u2013 No unnecessary data storage.<p>Who Is This For?<p>- Individual devs who want faster PR reviews.<p>- Teams &amp; startups looking to reduce code review bottlenecks.<p>- Open-source maintainers dealing with large volumes of PRs.<p>Try PullSense for Free @ PullSense.com<p>Would love to hear your thoughts, feedback, and ideas for improvements! Happy coding!","title":"Show HN: PullSense \u2013 AI-Powered PR Reviews for GitHub","updated_at":"2025-02-14T15:05:47Z","url":"https://www.pullsense.com/"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"vignesh_warar"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["code","review","ai","generated","bottleneck"],"value":"Hey HN, I\u2019m Vignesh, solo dev.<p>Handler is a Mac app for Codex and OpenCode that adds a <em>review</em> layer while the agent is generating <em>code</em>.<p>Every edit comes with a short explanation: what changed, why it changed, and what it touches. If one edit needs more context, you can open a side chat on just that change and ask follow-ups without derailing the main agent run.<p>The goal is to build a mental model as the <em>code</em> is <em>generated</em>, instead of waiting until the end and reviewing one giant diff cold.<p>It\u2019s the same idea that makes stacked PRs easier to <em>review</em>: smaller, understandable units. Handler applies that at <em>AI</em> generation time, before the change turns into one giant diff.<p>This year I mostly stopped writing <em>code</em> by hand. I drive agents now, and I\u2019m faster for it.<p>But a few months in I noticed a problem. The agent would come back with a 400-line change, tests green, diff looked reasonable, and after the first few chunks I\u2019d pretty much lose the mental model. At that point I wasn\u2019t really reviewing anymore. I was skimming the shape of the change and moving on.<p>I know that\u2019s not the ideal way to drive an agent. But I also don\u2019t want to slow the whole thing down and manually inspect every line like it\u2019s 2022. The whole point of using these tools is speed.<p>So the <em>bottleneck</em> stopped being writing <em>code</em>. It became understanding the <em>code</em> fast enough to stay in control of my own project.<p>Handler is what I built to fix that for myself:<p>- Every edit the agent proposes comes with a plain explanation of what that specific change does and why.\n- The explanation is attached to the edit, so you build context incrementally instead of reading one huge summary at the end.\n- You can pull any single edit into a side chat and ask \u201cwhy this approach?\u201d, \u201cwhat else does this affect?\u201d, or \u201credo this part (soon)\u201d without blowing up the main agent context.\n- You go edit by edit and accept or reject, instead of staring at one wall of diff and hoping.\n- It runs on your existing Codex and OpenCode setups, with worktrees so parallel runs don\u2019t collide.\n- It also has a built-in terminal that feels closer to a Chrome DevTools console than a plain terminal: command output is easier to inspect, the agent can read the terminal state, and there\u2019s a native JSON viewer/builder for working with structured data without copy-pasting into another tool.<p>What it\u2019s not: a <em>review</em> bot like CodeRabbit or Greptile. I use those, and they catch real bugs. But they <em>review</em> the <em>code</em> after the fact.<p>Handler points earlier in the workflow. It helps you <em>review</em> while the agent is producing the change, so you can keep the mental model instead of trying to reconstruct it later from a finished PR.<p>I\u2019ve been using it daily and can\u2019t go back to merging agent changes blind. If you\u2019ve felt the same problem with large <em>AI</em>-<em>generated</em> diffs, I\u2019d love for you to try it and tell me where it falls over."},"title":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["review","ai"],"value":"Show HN: <em>Review</em>-First <em>AI</em> IDE, Built on Codex and OpenCode"},"url":{"matchLevel":"none","matchedWords":[],"value":"https://handler.team/"}},"_tags":["story","author_vignesh_warar","story_48367682","show_hn"],"author":"vignesh_warar","created_at":"2026-06-02T08:58:24Z","created_at_i":1780390704,"num_comments":0,"objectID":"48367682","points":4,"story_id":48367682,"story_text":"Hey HN, I\u2019m Vignesh, solo dev.<p>Handler is a Mac app for Codex and OpenCode that adds a review layer while the agent is generating code.<p>Every edit comes with a short explanation: what changed, why it changed, and what it touches. If one edit needs more context, you can open a side chat on just that change and ask follow-ups without derailing the main agent run.<p>The goal is to build a mental model as the code is generated, instead of waiting until the end and reviewing one giant diff cold.<p>It\u2019s the same idea that makes stacked PRs easier to review: smaller, understandable units. Handler applies that at AI generation time, before the change turns into one giant diff.<p>This year I mostly stopped writing code by hand. I drive agents now, and I\u2019m faster for it.<p>But a few months in I noticed a problem. The agent would come back with a 400-line change, tests green, diff looked reasonable, and after the first few chunks I\u2019d pretty much lose the mental model. At that point I wasn\u2019t really reviewing anymore. I was skimming the shape of the change and moving on.<p>I know that\u2019s not the ideal way to drive an agent. But I also don\u2019t want to slow the whole thing down and manually inspect every line like it\u2019s 2022. The whole point of using these tools is speed.<p>So the bottleneck stopped being writing code. It became understanding the code fast enough to stay in control of my own project.<p>Handler is what I built to fix that for myself:<p>- Every edit the agent proposes comes with a plain explanation of what that specific change does and why.\n- The explanation is attached to the edit, so you build context incrementally instead of reading one huge summary at the end.\n- You can pull any single edit into a side chat and ask \u201cwhy this approach?\u201d, \u201cwhat else does this affect?\u201d, or \u201credo this part (soon)\u201d without blowing up the main agent context.\n- You go edit by edit and accept or reject, instead of staring at one wall of diff and hoping.\n- It runs on your existing Codex and OpenCode setups, with worktrees so parallel runs don\u2019t collide.\n- It also has a built-in terminal that feels closer to a Chrome DevTools console than a plain terminal: command output is easier to inspect, the agent can read the terminal state, and there\u2019s a native JSON viewer&#x2F;builder for working with structured data without copy-pasting into another tool.<p>What it\u2019s not: a review bot like CodeRabbit or Greptile. I use those, and they catch real bugs. But they review the code after the fact.<p>Handler points earlier in the workflow. It helps you review while the agent is producing the change, so you can keep the mental model instead of trying to reconstruct it later from a finished PR.<p>I\u2019ve been using it daily and can\u2019t go back to merging agent changes blind. If you\u2019ve felt the same problem with large AI-generated diffs, I\u2019d love for you to try it and tell me where it falls over.","title":"Show HN: Review-First AI IDE, Built on Codex and OpenCode","updated_at":"2026-06-02T21:50:26Z","url":"https://handler.team/"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"ethanr2000"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["code","review","ai","generated","bottleneck"],"value":"I'm looking for some advice for small tech teams (~3 devs) developing quickly with LLMs.<p>As most people are, we are leaning more and more on LLMs to generate <em>code</em>. We use Cursor in the side-panel to maintain strict control and engineering quality standards of our application.<p>However, we are finding more and more that the <em>code</em> <em>review</em> is a tighter <em>bottleneck</em> in development, with PRs stacking up quickly. The balance of how long it takes to generate vs <em>review</em> <em>code</em> has skewed in the last year. <em>Code</em> <em>review</em> now takes proportionally more time.<p>We have tried integrating tools like CodeRabbitAI, but have not found it to be a silver bullet. It is useful for reporting basic bugs and missing test cases, but usually misses critical issues in the context of the wider application.<p>Additionally, <em>AI</em> <em>code</em> <em>review</em> misses the important <em>code</em> <em>review</em> goal of sharing the context and understanding and ownership with the rest of the team.<p>I'm concerned that we're ultimately looking at a bleak contradiction. We want both to generate new features quicker than can be traditionally <em>code</em> reviewed (i.e. - understood), and still want to personally understand the architecture and <em>code</em> that is being <em>generated</em>.<p>And so I'm looking for advice. What have you tried and found to be effective? What needs to be sacrificed in a professional engineering team generating <em>code</em> faster than ever before?"},"title":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["code","review"],"value":"Ask HN: What happens to <em>code</em> <em>review</em> process when using LLMs?"}},"_tags":["story","author_ethanr2000","story_49461811","ask_hn"],"author":"ethanr2000","children":[49462511,49470886,49480454,49483931,49506025,49535243,49544570,49624192,49624466],"created_at":"2026-08-27T08:58:44Z","created_at_i":1787821124,"num_comments":8,"objectID":"49461811","points":3,"story_id":49461811,"story_text":"I&#x27;m looking for some advice for small tech teams (~3 devs) developing quickly with LLMs.<p>As most people are, we are leaning more and more on LLMs to generate code. We use Cursor in the side-panel to maintain strict control and engineering quality standards of our application.<p>However, we are finding more and more that the code review is a tighter bottleneck in development, with PRs stacking up quickly. The balance of how long it takes to generate vs review code has skewed in the last year. Code review now takes proportionally more time.<p>We have tried integrating tools like CodeRabbitAI, but have not found it to be a silver bullet. It is useful for reporting basic bugs and missing test cases, but usually misses critical issues in the context of the wider application.<p>Additionally, AI code review misses the important code review goal of sharing the context and understanding and ownership with the rest of the team.<p>I&#x27;m concerned that we&#x27;re ultimately looking at a bleak contradiction. We want both to generate new features quicker than can be traditionally code reviewed (i.e. - understood), and still want to personally understand the architecture and code that is being generated.<p>And so I&#x27;m looking for advice. What have you tried and found to be effective? What needs to be sacrificed in a professional engineering team generating code faster than ever before?","title":"Ask HN: What happens to code review process when using LLMs?","updated_at":"2026-09-09T22:42:51Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"alfarez"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["code","review","ai","generated","bottleneck"],"value":"Spec + Data<p>Not a fully formed thought, and apologies for the brain fart, but...<p>This post was inspired by an article on latent.space about how, first, human coding &quot;died&quot;. Then now we're going to see the demise of the &quot;pull request&quot;.<p>If you're not familiar, a pull request, or &quot;PR&quot;, is a request to change some <em>code</em> in software, by introducing some new <em>code</em> that you have written yourself. So someone has to <em>review</em> that <em>code</em>, make sure it's all written &quot;properly&quot; and then approve or reject it.<p><em>Code</em> can now be <em>generated</em> 1000x faster by <em>AI</em>. And <em>AI</em> <em>generated</em> <em>code</em> still needs to be merged into the main <em>code</em>. And if every chunk of <em>AI</em> <em>generated</em> <em>code</em> needs a pull request, that's thousands of pull requests to <em>review</em> by humans. We then become the <em>bottleneck</em>.<p>Then why not get <em>AI</em> to do the <em>review</em>? It can do it much faster than humans. The \n@latentspacepod\n article  asks why have pull-requests at all? It was <em>AI</em> generating <em>code</em>. Why have the same <em>AI</em> look at it again?<p>Personally, I disagree, for now anyway. I think we're in a transition period where humans still need some control. And while we don't write <em>code</em> anymore, and I do believe PRs should be reviewed by <em>AI</em>, I think humans should still manage the PR agents - for example defining rules for the <em>review</em> agents to follow, checking that they did follow the rules, etc.<p>But that's transitional, and besides my point. What I do agree with in article is where humans will be needed. And where we're needed is further up the software development chain, into the realm of requirements and testing.<p><em>Code</em> is not created in a vacuum. It is created to automate work. It is created to fulfill a specific requirement. And this requirement will still be created by humans.<p>And if we can be clear about what we need - the requirements - then we can also run automated tests to check that the <em>code</em> meets our requirements.<p>If <em>code</em> is cheap, and instant, and humans stop become the <em>bottleneck</em> to deploying <em>code</em>, what does this mean for <em>code</em> ownership?<p>It means it doesn't make sense to &quot;own&quot; <em>code</em> anymore. So what's worth owning?<p>Spec and Data.<p>How your organisation runs, all its rules, all its goals. These make up your software specification (spec).<p>All the information your org collects, all the information it needs to run. That's your data.<p>If you have a clear, tight, spec. And a database that holds all your data. Then you can reproduce all the software that you need instantly.<p>An <em>AI</em> can read your spec. Then create automated tests against that spec. Generate all the <em>code</em> needed. Connect to your data. Test the <em>code</em> against the spec. Verify that it is all correct. Deploy your <em>code</em>. And hand you the keys (login) so you can drive it straight away.<p>This has several further implications:<p>- Should an org's investment now turn to speccing and testing?<p>- Should we work on a more standard way of defining spec and data schemas?<p>- What does this mean for software development agencies, if producing and reviewing <em>code</em> is not needed anymore?<p>- When an enterprise buys from Google and Microsoft, what are they really buying, if it's not software anymore?<p>Definitely more questions than answers. And things will continue to change fast for the software development industry.<p>And for organisations - if you already create and document great spec, and have automated tests in place, and have good data policies, then you're in a great place."},"title":{"matchLevel":"none","matchedWords":[],"value":"Spec and Data"}},"_tags":["story","author_alfarez","story_47230554","ask_hn"],"author":"alfarez","created_at":"2026-03-03T10:30:43Z","created_at_i":1772533843,"num_comments":0,"objectID":"47230554","points":1,"story_id":47230554,"story_text":"Spec + Data<p>Not a fully formed thought, and apologies for the brain fart, but...<p>This post was inspired by an article on latent.space about how, first, human coding &quot;died&quot;. Then now we&#x27;re going to see the demise of the &quot;pull request&quot;.<p>If you&#x27;re not familiar, a pull request, or &quot;PR&quot;, is a request to change some code in software, by introducing some new code that you have written yourself. So someone has to review that code, make sure it&#x27;s all written &quot;properly&quot; and then approve or reject it.<p>Code can now be generated 1000x faster by AI. And AI generated code still needs to be merged into the main code. And if every chunk of AI generated code needs a pull request, that&#x27;s thousands of pull requests to review by humans. We then become the bottleneck.<p>Then why not get AI to do the review? It can do it much faster than humans. The \n@latentspacepod\n article  asks why have pull-requests at all? It was AI generating code. Why have the same AI look at it again?<p>Personally, I disagree, for now anyway. I think we&#x27;re in a transition period where humans still need some control. And while we don&#x27;t write code anymore, and I do believe PRs should be reviewed by AI, I think humans should still manage the PR agents - for example defining rules for the review agents to follow, checking that they did follow the rules, etc.<p>But that&#x27;s transitional, and besides my point. What I do agree with in article is where humans will be needed. And where we&#x27;re needed is further up the software development chain, into the realm of requirements and testing.<p>Code is not created in a vacuum. It is created to automate work. It is created to fulfill a specific requirement. And this requirement will still be created by humans.<p>And if we can be clear about what we need - the requirements - then we can also run automated tests to check that the code meets our requirements.<p>If code is cheap, and instant, and humans stop become the bottleneck to deploying code, what does this mean for code ownership?<p>It means it doesn&#x27;t make sense to &quot;own&quot; code anymore. So what&#x27;s worth owning?<p>Spec and Data.<p>How your organisation runs, all its rules, all its goals. These make up your software specification (spec).<p>All the information your org collects, all the information it needs to run. That&#x27;s your data.<p>If you have a clear, tight, spec. And a database that holds all your data. Then you can reproduce all the software that you need instantly.<p>An AI can read your spec. Then create automated tests against that spec. Generate all the code needed. Connect to your data. Test the code against the spec. Verify that it is all correct. Deploy your code. And hand you the keys (login) so you can drive it straight away.<p>This has several further implications:<p>- Should an org&#x27;s investment now turn to speccing and testing?<p>- Should we work on a more standard way of defining spec and data schemas?<p>- What does this mean for software development agencies, if producing and reviewing code is not needed anymore?<p>- When an enterprise buys from Google and Microsoft, what are they really buying, if it&#x27;s not software anymore?<p>Definitely more questions than answers. And things will continue to change fast for the software development industry.<p>And for organisations - if you already create and document great spec, and have automated tests in place, and have good data policies, then you&#x27;re in a great place.","title":"Spec and Data","updated_at":"2026-03-05T23:40:28Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"liu1700"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["code","review","ai","generated","bottleneck"],"value":"I have used coding agents a lot in my work.<p>While the <em>code</em> generation output has significantly increased, the <em>review</em> process has become a severe <em>bottleneck</em> to me.<p>The agents are producing a massive volume of PR. Reviewing this amount of <em>AI</em>-<em>generated</em> <em>code</em> requires deep cognitive effort to ensure architectural alignment, verify logic, etc.<p>Any insights on scaling the human <em>review</em> process to sustainably match agent throughput?"},"title":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["review"],"value":"Ask HN: How do you manage PR <em>review</em> fatigue from coding agents?"}},"_tags":["story","author_liu1700","story_47418016","ask_hn"],"author":"liu1700","children":[47435068,47458928,47560731],"created_at":"2026-03-17T20:42:17Z","created_at_i":1773780137,"num_comments":1,"objectID":"47418016","points":2,"story_id":47418016,"story_text":"I have used coding agents a lot in my work.<p>While the code generation output has significantly increased, the review process has become a severe bottleneck to me.<p>The agents are producing a massive volume of PR. Reviewing this amount of AI-generated code requires deep cognitive effort to ensure architectural alignment, verify logic, etc.<p>Any insights on scaling the human review process to sustainably match agent throughput?","title":"Ask HN: How do you manage PR review fatigue from coding agents?","updated_at":"2026-03-30T03:50:18Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"rohansood15"},"story_text":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["code","review","generated","bottleneck"],"value":"Hi HN, we are Asankhaya and Rohan, founders of Patched (<a href=\"https://patched.codes\">https://patched.codes</a>). We help dev teams accelerate tasks like <em>code</em> <em>reviews</em>, docs, and patches through customizable, self-hostable workflows. Here\u2019s a quick video walkthrough: <a href=\"https://youtu.be/5hvWGB5avVo\" rel=\"nofollow\">https://youtu.be/5hvWGB5avVo</a><p>There is a lot of excitement around <em>code</em> generation and the development inner loop. But having built DevSecOps startups previously, we know how the <em>bottlenecks</em> developers face often occur in the \u201couter loop\u201d, especially after the <em>code</em> is written. With Patched, we want to help <em>code</em> get shipped as fast as it is <em>generated</em>.<p>Patched has two core components.  First is the workflow builder that switches seamlessly between no-<em>code</em> and full-<em>code</em>. Second is the chat-based query interface for your <em>code</em>, logs, and issue tracker. When used together, they can help orchestrate and automate the most painful parts of the software development lifecycle.<p>Here is an example PR created by a patchflow that automates SDK generation with complex type information: <a href=\"https://github.com/stack-auth/stack/pull/300\">https://github.com/stack-auth/stack/pull/300</a>.<p>Under the hood, Patched is powered by our patchwork library (<a href=\"https://github.com/patched-codes/patchwork\">https://github.com/patched-codes/patchwork</a>) and an LLM optimization proxy(<a href=\"https://github.com/codelion/optillm\">https://github.com/codelion/optillm</a>) - both of which we have open-sourced. You can run these workflows within your CI/CD pipeline, or from the command line, completely independent of our platform. This gives you full control without being locked in, while allowing us to build a monetizable product around it.<p>While there are some great point solutions for tackling individual tasks, we believe the real solution lies in an open, holistic approach\u2014one that teams can tweak, extend, or self-host.<p>You can try Patched at <a href=\"https://app.patched.codes/signin\">https://app.patched.codes/signin</a> - we\u2019d love to hear your feedback on our approach and the user experience."},"title":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["code","ai"],"value":"Launch HN: Patched (YC S24) \u2013 <em>AI</em> workflows for post-<em>code</em> tasks"}},"_tags":["story","author_rohansood15","story_42009089","launch_hn"],"author":"rohansood15","children":[42009382,42010068,42010510,42010735,42011291,42011838,42011888,42012706],"created_at":"2024-10-31T17:27:41Z","created_at_i":1730395661,"num_comments":20,"objectID":"42009089","points":67,"story_id":42009089,"story_text":"Hi HN, we are Asankhaya and Rohan, founders of Patched (<a href=\"https:&#x2F;&#x2F;patched.codes\">https:&#x2F;&#x2F;patched.codes</a>). We help dev teams accelerate tasks like code reviews, docs, and patches through customizable, self-hostable workflows. Here\u2019s a quick video walkthrough: <a href=\"https:&#x2F;&#x2F;youtu.be&#x2F;5hvWGB5avVo\" rel=\"nofollow\">https:&#x2F;&#x2F;youtu.be&#x2F;5hvWGB5avVo</a><p>There is a lot of excitement around code generation and the development inner loop. But having built DevSecOps startups previously, we know how the bottlenecks developers face often occur in the \u201couter loop\u201d, especially after the code is written. With Patched, we want to help code get shipped as fast as it is generated.<p>Patched has two core components.  First is the workflow builder that switches seamlessly between no-code and full-code. Second is the chat-based query interface for your code, logs, and issue tracker. When used together, they can help orchestrate and automate the most painful parts of the software development lifecycle.<p>Here is an example PR created by a patchflow that automates SDK generation with complex type information: <a href=\"https:&#x2F;&#x2F;github.com&#x2F;stack-auth&#x2F;stack&#x2F;pull&#x2F;300\">https:&#x2F;&#x2F;github.com&#x2F;stack-auth&#x2F;stack&#x2F;pull&#x2F;300</a>.<p>Under the hood, Patched is powered by our patchwork library (<a href=\"https:&#x2F;&#x2F;github.com&#x2F;patched-codes&#x2F;patchwork\">https:&#x2F;&#x2F;github.com&#x2F;patched-codes&#x2F;patchwork</a>) and an LLM optimization proxy(<a href=\"https:&#x2F;&#x2F;github.com&#x2F;codelion&#x2F;optillm\">https:&#x2F;&#x2F;github.com&#x2F;codelion&#x2F;optillm</a>) - both of which we have open-sourced. You can run these workflows within your CI&#x2F;CD pipeline, or from the command line, completely independent of our platform. This gives you full control without being locked in, while allowing us to build a monetizable product around it.<p>While there are some great point solutions for tackling individual tasks, we believe the real solution lies in an open, holistic approach\u2014one that teams can tweak, extend, or self-host.<p>You can try Patched at <a href=\"https:&#x2F;&#x2F;app.patched.codes&#x2F;signin\">https:&#x2F;&#x2F;app.patched.codes&#x2F;signin</a> - we\u2019d love to hear your feedback on our approach and the user experience.","title":"Launch HN: Patched (YC S24) \u2013 AI workflows for post-code tasks","updated_at":"2024-11-23T23:25:37Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"bveiseh"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["code","review","ai","generated","bottleneck"],"value":"Hey HN! We're Brandon, Sam, and Akul from MindFort (<a href=\"https://mindfort.ai\">https://mindfort.<em>ai</em></a>). We're building autonomous <em>AI</em> agents that continuously find, validate, and patch security vulnerabilities in web applications\u2014essentially creating an <em>AI</em> red team that runs 24/7.<p>Here's a demo: <a href=\"https://www.loom.com/share/e56faa07d90b417db09bb4454dce8d5a\" rel=\"nofollow\">https://www.loom.com/share/e56faa07d90b417db09bb4454dce8d5a</a><p>Security testing today is increasingly challenging. Traditional scanners generate 30-50% false positives, drowning engineering teams in noise. Manual penetration testing happens quarterly at best, costs tens of thousands per assessment, and takes weeks to complete. Meanwhile, teams are shipping <em>code</em> faster than ever with <em>AI</em> assistance, but security <em>reviews</em> have become an even bigger <em>bottleneck</em>.<p>All three of us encountered this problem from different angles. Brandon worked at ProjectDiscovery building the Nuclei scanner, then at NetSPI (one of the largest pen testing firms) building <em>AI</em> tools for testers. Sam was a senior engineer at Salesforce leading security for Tableau. He dealt firsthand with juggling security findings and managing remediations. Akul did his master's on <em>AI</em> and security, co-authored papers on using LLMs for ecurity attacks, and participated in red-teams at OpenAI and Anthropic.<p>We all realized that <em>AI</em> agents were going to fundamentally change security testing, and that the wave of <em>AI</em>-<em>generated</em> <em>code</em> would need an equally powerful solution to keep it secure.<p>We've built <em>AI</em> agents that perform reconnaissance, exploit vulnerabilities, and suggest patches\u2014similar to how a human penetration tester works. The key difference from traditional scanners is that our agents validate exploits in runtime environments before reporting them, reducing false positives.<p>We use multiple foundational models orchestrated together. The agents perform recon to understand the attack surface, then use that context to inform testing strategies. When they find potential vulnerabilities, they spin up isolated environments to validate exploitation. If successful, they analyze the codebase to generate contextual patches.<p>What makes this different from existing tools? Validation through exploitation: We don't just pattern-match\u2014we exploit vulnerabilities to prove they're real; - Codebase integration: The agents understand your <em>code</em> structure to find complex logic bugs and suggest appropriate fixes; - Continuous operation: Instead of point-in-time assessments, we're constantly testing as your <em>code</em> evolves; - Attack chain discovery: The agents can find multi-step vulnerabilities that require chaining different issues together.<p>We're currently in early access, working with initial partners to refine the platform. Our agents are already finding vulnerabilities that other tools miss and scoring well on penetration testing benchmarks.<p>Looking forward to your thoughts and comments!"},"title":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["ai"],"value":"Launch HN: MindFort (YC X25) \u2013 <em>AI</em> agents for continuous pentesting"}},"_tags":["story","author_bveiseh","story_44117465","launch_hn"],"author":"bveiseh","children":[44117925,44117986,44118218,44118538,44119091,44119206,44120360,44123693,44127697,44128728,44163455],"created_at":"2025-05-28T16:00:44Z","created_at_i":1748448044,"num_comments":24,"objectID":"44117465","points":60,"story_id":44117465,"story_text":"Hey HN! We&#x27;re Brandon, Sam, and Akul from MindFort (<a href=\"https:&#x2F;&#x2F;mindfort.ai\">https:&#x2F;&#x2F;mindfort.ai</a>). We&#x27;re building autonomous AI agents that continuously find, validate, and patch security vulnerabilities in web applications\u2014essentially creating an AI red team that runs 24&#x2F;7.<p>Here&#x27;s a demo: <a href=\"https:&#x2F;&#x2F;www.loom.com&#x2F;share&#x2F;e56faa07d90b417db09bb4454dce8d5a\" rel=\"nofollow\">https:&#x2F;&#x2F;www.loom.com&#x2F;share&#x2F;e56faa07d90b417db09bb4454dce8d5a</a><p>Security testing today is increasingly challenging. Traditional scanners generate 30-50% false positives, drowning engineering teams in noise. Manual penetration testing happens quarterly at best, costs tens of thousands per assessment, and takes weeks to complete. Meanwhile, teams are shipping code faster than ever with AI assistance, but security reviews have become an even bigger bottleneck.<p>All three of us encountered this problem from different angles. Brandon worked at ProjectDiscovery building the Nuclei scanner, then at NetSPI (one of the largest pen testing firms) building AI tools for testers. Sam was a senior engineer at Salesforce leading security for Tableau. He dealt firsthand with juggling security findings and managing remediations. Akul did his master&#x27;s on AI and security, co-authored papers on using LLMs for ecurity attacks, and participated in red-teams at OpenAI and Anthropic.<p>We all realized that AI agents were going to fundamentally change security testing, and that the wave of AI-generated code would need an equally powerful solution to keep it secure.<p>We&#x27;ve built AI agents that perform reconnaissance, exploit vulnerabilities, and suggest patches\u2014similar to how a human penetration tester works. The key difference from traditional scanners is that our agents validate exploits in runtime environments before reporting them, reducing false positives.<p>We use multiple foundational models orchestrated together. The agents perform recon to understand the attack surface, then use that context to inform testing strategies. When they find potential vulnerabilities, they spin up isolated environments to validate exploitation. If successful, they analyze the codebase to generate contextual patches.<p>What makes this different from existing tools? Validation through exploitation: We don&#x27;t just pattern-match\u2014we exploit vulnerabilities to prove they&#x27;re real; - Codebase integration: The agents understand your code structure to find complex logic bugs and suggest appropriate fixes; - Continuous operation: Instead of point-in-time assessments, we&#x27;re constantly testing as your code evolves; - Attack chain discovery: The agents can find multi-step vulnerabilities that require chaining different issues together.<p>We&#x27;re currently in early access, working with initial partners to refine the platform. Our agents are already finding vulnerabilities that other tools miss and scoring well on penetration testing benchmarks.<p>Looking forward to your thoughts and comments!","title":"Launch HN: MindFort (YC X25) \u2013 AI agents for continuous pentesting","updated_at":"2026-05-14T09:00:23Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"wayland_jeremy"},"story_text":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["code","review","generated","bottleneck"],"value":"<em>Code</em> <em>review</em> is the new <em>bottleneck</em>. &quot;Tests passing&quot; is no longer sufficient to trust the changes, and the (human) cost of evaluating the quality and robustness of new agent-written contributions is skyrocketing. We built Topos to evaluate <em>code</em> quality based on the structural properties of the programs themselves. We map your files to graphs (AST, CFG, CPG, MDG) and calculate metrics that can characterize how simple, composable, or secure your programs are. Agents can use this tool as they write and optimize based on your preferences. And yes, the inspiration for the repository is from category theory: this is inspired by a topos for program evaluation, that comes equipped with objects (program representations), morphisms (maps on graphs), probes, profunctors, test-coverage metrics, and a custom subobject classifier (Heyting algebra <em>generated</em> by the 3 pillars of evaluation) that affords a highly structured framework for awarding medals for program quality.<p>GitHub: <a href=\"https://github.com/Krv-Labs/topos\" rel=\"nofollow\">https://github.com/Krv-Labs/topos</a><p>Open Source. BSD-3 License. CLI, MCP Server &amp; VS <em>Code</em> Extension."},"title":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["code"],"value":"Show HN: Topos \u2013 Structural <em>code</em> quality metrics for agent-written programs"},"url":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["code","ai"],"value":"https://krv.<em>ai</em>/field-notes/evaluating-<em>code</em>-generation"}},"_tags":["story","author_wayland_jeremy","story_48678841","show_hn"],"author":"wayland_jeremy","children":[48684665],"created_at":"2026-06-25T20:32:23Z","created_at_i":1782419543,"num_comments":1,"objectID":"48678841","points":5,"story_id":48678841,"story_text":"Code review is the new bottleneck. &quot;Tests passing&quot; is no longer sufficient to trust the changes, and the (human) cost of evaluating the quality and robustness of new agent-written contributions is skyrocketing. We built Topos to evaluate code quality based on the structural properties of the programs themselves. We map your files to graphs (AST, CFG, CPG, MDG) and calculate metrics that can characterize how simple, composable, or secure your programs are. Agents can use this tool as they write and optimize based on your preferences. And yes, the inspiration for the repository is from category theory: this is inspired by a topos for program evaluation, that comes equipped with objects (program representations), morphisms (maps on graphs), probes, profunctors, test-coverage metrics, and a custom subobject classifier (Heyting algebra generated by the 3 pillars of evaluation) that affords a highly structured framework for awarding medals for program quality.<p>GitHub: <a href=\"https:&#x2F;&#x2F;github.com&#x2F;Krv-Labs&#x2F;topos\" rel=\"nofollow\">https:&#x2F;&#x2F;github.com&#x2F;Krv-Labs&#x2F;topos</a><p>Open Source. BSD-3 License. CLI, MCP Server &amp; VS Code Extension.","title":"Show HN: Topos \u2013 Structural code quality metrics for agent-written programs","updated_at":"2026-06-26T10:05:10Z","url":"https://krv.ai/field-notes/evaluating-code-generation"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"unfavalen"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["code","review","ai","generated","bottleneck"],"value":"I kept running into the same issue whenever starting a new project: the setup phase consumed more time than the actual feature work. Preparing boilerplate, restructuring directories, performing refactors, resolving dependency conflicts, and wiring framework logic consistently took hours before I could write meaningful <em>code</em>. Even with modern tooling, the early-stage workload was nearly identical across projects.<p>To remove that <em>bottleneck</em>, I built Bleenk, an <em>AI</em> coding agent that operates directly on real repositories. Instead of generating isolated snippets, it performs multi-step modifications across the codebase. It creates branches, edits files, restructures modules, rewrites components, and prepares pull requests. The agent is designed to understand the full repository context, not just the last prompt.<p>Bleenk uses an isolated Vercel Sandbox environment to execute and validate <em>generated</em> <em>code</em>, ensuring changes run correctly before they ever reach a PR. It also includes Bleenk-Mini, a model optimized for repository-level reasoning, multi-file coordination, and incremental refactoring.<p>The result is that I can ship full-stack application features in minutes instead of hours. In internal use, tasks that previously required three to five hours of manual engineering now complete in under fifteen minutes with consistent diffs and minimal manual cleanup.<p>I am interested in technical feedback: which repository-level operations do you think an automated agent should prioritize, and what guardrails or <em>review</em> patterns are most important for safe <em>code</em> modification?"},"title":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["ai"],"value":"Show HN: I built an <em>AI</em> coding agent that ships real apps fast"},"url":{"matchLevel":"none","matchedWords":[],"value":"https://bleenk.app/waitlist"}},"_tags":["story","author_unfavalen","story_46204590","show_hn"],"author":"unfavalen","created_at":"2025-12-09T13:13:15Z","created_at_i":1765285995,"num_comments":0,"objectID":"46204590","points":1,"story_id":46204590,"story_text":"I kept running into the same issue whenever starting a new project: the setup phase consumed more time than the actual feature work. Preparing boilerplate, restructuring directories, performing refactors, resolving dependency conflicts, and wiring framework logic consistently took hours before I could write meaningful code. Even with modern tooling, the early-stage workload was nearly identical across projects.<p>To remove that bottleneck, I built Bleenk, an AI coding agent that operates directly on real repositories. Instead of generating isolated snippets, it performs multi-step modifications across the codebase. It creates branches, edits files, restructures modules, rewrites components, and prepares pull requests. The agent is designed to understand the full repository context, not just the last prompt.<p>Bleenk uses an isolated Vercel Sandbox environment to execute and validate generated code, ensuring changes run correctly before they ever reach a PR. It also includes Bleenk-Mini, a model optimized for repository-level reasoning, multi-file coordination, and incremental refactoring.<p>The result is that I can ship full-stack application features in minutes instead of hours. In internal use, tasks that previously required three to five hours of manual engineering now complete in under fifteen minutes with consistent diffs and minimal manual cleanup.<p>I am interested in technical feedback: which repository-level operations do you think an automated agent should prioritize, and what guardrails or review patterns are most important for safe code modification?","title":"Show HN: I built an AI coding agent that ships real apps fast","updated_at":"2026-03-05T23:07:09Z","url":"https://bleenk.app/waitlist"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"Wizardrytezch"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["code","review","ai","generated","bottleneck"],"value":"*Problem:* I was spending $50+/month on ChatGPT API to <em>generate</em> product ideas. Results were inconsistent, required internet, and changed every run.<p>*Solution:* Passive-Gen \u2014 a 100% offline, deterministic idea generator. Same seed = identical output. Every time.<p>*How it works:*\n- Seeded RNG (Linear Congruential Generator)\n- 30+ templates per category (Gumroad, Etsy, Prompts)\n- Auto-scoring on 4 dimensions\n- Markdown + JSON output<p>*Example output for &quot;<em>AI</em> tools&quot;:*<p>*<em>CodeReview</em> Bot* \u2014 <em>AI</em>-powered <em>code review</em> automation that checks for security issues, performance <em>bottlenecks</em>, and style violations. Integrates with GitHub/GitLab. One-c...<p>Scores: Ease 8/10, Demand 9/10, Diff 7/10<p>*Tech stack:* TypeScript, Node.js, zero dependencies<p>*Open source:* <a href=\"https://github.com/CrazhHolmes/passive-gen\" rel=\"nofollow\">https://github.com/CrazhHolmes/passive-gen</a><p>*Question:* Would you use this for your side project research? What features would you add?"},"title":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["ai"],"value":"Show HN: Deterministic product idea generator (no <em>AI</em> APIs, works offline)"},"url":{"matchLevel":"none","matchedWords":[],"value":"https://github.com/CrazhHolmes/passive-gen"}},"_tags":["story","author_Wizardrytezch","story_46937481","show_hn"],"author":"Wizardrytezch","created_at":"2026-02-08T19:14:53Z","created_at_i":1770578093,"num_comments":0,"objectID":"46937481","points":1,"story_id":46937481,"story_text":"*Problem:* I was spending $50+&#x2F;month on ChatGPT API to generate product ideas. Results were inconsistent, required internet, and changed every run.<p>*Solution:* Passive-Gen \u2014 a 100% offline, deterministic idea generator. Same seed = identical output. Every time.<p>*How it works:*\n- Seeded RNG (Linear Congruential Generator)\n- 30+ templates per category (Gumroad, Etsy, Prompts)\n- Auto-scoring on 4 dimensions\n- Markdown + JSON output<p>*Example output for &quot;AI tools&quot;:*<p>*CodeReview Bot* \u2014 AI-powered code review automation that checks for security issues, performance bottlenecks, and style violations. Integrates with GitHub&#x2F;GitLab. One-c...<p>Scores: Ease 8&#x2F;10, Demand 9&#x2F;10, Diff 7&#x2F;10<p>*Tech stack:* TypeScript, Node.js, zero dependencies<p>*Open source:* <a href=\"https:&#x2F;&#x2F;github.com&#x2F;CrazhHolmes&#x2F;passive-gen\" rel=\"nofollow\">https:&#x2F;&#x2F;github.com&#x2F;CrazhHolmes&#x2F;passive-gen</a><p>*Question:* Would you use this for your side project research? What features would you add?","title":"Show HN: Deterministic product idea generator (no AI APIs, works offline)","updated_at":"2026-03-05T23:32:41Z","url":"https://github.com/CrazhHolmes/passive-gen"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"sanketsaurav"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["code","review","ai","generated","bottleneck"],"value":"Hi there, HN! We\u2019re Jai and Sanket from DeepSource (YC W20), and today we\u2019re launching Autofix Bot, a hybrid static analysis + <em>AI</em> agent purpose-built for in-the-loop use with <em>AI</em> coding agents.<p><em>AI</em> coding agents have made <em>code</em> generation nearly free, and they\u2019ve shifted the <em>bottleneck</em> to <em>code</em> <em>review</em>. Static-only analysis with a fixed set of checkers isn\u2019t enough. LLM-only <em>review</em> has several limitations: non-deterministic across runs, low recall on security issues, expensive at scale, and a tendency to get \u2018distracted\u2019.<p>We spent the last 6 years building a deterministic, static-analysis-only <em>code</em> <em>review</em> product. Earlier this year, we started thinking about this problem from the ground up and realized that static analysis solves key blind spots of LLM-only reviews. Over the past six months, we built a new \u2018hybrid\u2019 agent loop that uses static analysis and frontier <em>AI</em> agents together to outperform both static-only and LLM-only tools in finding and fixing <em>code</em> quality and security issues. Today, we\u2019re opening it up publicly.<p>Here\u2019s how the hybrid architecture works:<p>- Static pass: 5,000+ deterministic checkers (<em>code</em> quality, security, performance) establish a high-precision baseline. A sub-agent suppresses context-specific false positives.<p>- <em>AI</em> <em>review</em>: The agent reviews <em>code</em> with static findings as anchors. Has access to AST, data-flow graphs, control-flow, import graphs as tools, not just grep and usual shell commands.<p>- Remediation: Sub-agents <em>generate</em> fixes. Static harness validates all edits before emitting a clean git patch.<p>Static solves key LLM problems: non-determinism across runs, low recall on security issues (LLMs get distracted by style), and cost (static narrowing reduces prompt size and tool calls).<p>On the OpenSSF CVE Benchmark [1] (200+ real JS/TS vulnerabilities), we hit 81.2% accuracy and 80.0% F1; vs Cursor Bugbot (74.5% accuracy, 77.42% F1), Claude <em>Code</em> (71.5% accuracy, 62.99% F1), CodeRabbit (59.4% accuracy, 36.19% F1), and Semgrep CE (56.9% accuracy, 38.26% F1). \nOn secrets detection, 92.8% F1; vs Gitleaks (75.6%), detect-secrets (64.1%), and TruffleHog (41.2%). We use our open-source classification model for this. [2]<p>Full methodology and how we evaluated each tool: <a href=\"https://autofix.bot/benchmarks\" rel=\"nofollow\">https://autofix.bot/benchmarks</a><p>You can use Autofix Bot interactively on any repository using our TUI, as a plugin in Claude <em>Code</em>, or with our MCP on any compatible <em>AI</em> client (like OpenAI Codex).[3] We\u2019re specifically building for <em>AI</em> coding agent-first workflows, so you can ask your agent to run Autofix Bot on every checkpoint autonomously.<p>Give us a shot today: <a href=\"https://autofix.bot\" rel=\"nofollow\">https://autofix.bot</a>. We\u2019d love to hear any feedback!<p>---<p>[1] <a href=\"https://github.com/ossf-cve-benchmark/ossf-cve-benchmark\" rel=\"nofollow\">https://github.com/ossf-cve-benchmark/ossf-cve-benchmark</a><p>[2] <a href=\"https://huggingface.co/deepsource/Narada-3.2-3B-v1\" rel=\"nofollow\">https://huggingface.co/deepsource/Narada-3.2-3B-v1</a><p>[3] <a href=\"https://autofix.bot/manual/#terminal-ui\" rel=\"nofollow\">https://autofix.bot/manual/#terminal-ui</a>"},"title":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["code","review","ai"],"value":"Show HN: Autofix Bot \u2013 Hybrid static analysis and <em>AI</em> <em>code</em> <em>review</em> agent"}},"_tags":["story","author_sanketsaurav","story_46237358","show_hn"],"author":"sanketsaurav","children":[46244233,46244611,46244909,46245516,46246622,46249600],"created_at":"2025-12-11T21:24:34Z","created_at_i":1765488274,"num_comments":13,"objectID":"46237358","points":37,"story_id":46237358,"story_text":"Hi there, HN! We\u2019re Jai and Sanket from DeepSource (YC W20), and today we\u2019re launching Autofix Bot, a hybrid static analysis + AI agent purpose-built for in-the-loop use with AI coding agents.<p>AI coding agents have made code generation nearly free, and they\u2019ve shifted the bottleneck to code review. Static-only analysis with a fixed set of checkers isn\u2019t enough. LLM-only review has several limitations: non-deterministic across runs, low recall on security issues, expensive at scale, and a tendency to get \u2018distracted\u2019.<p>We spent the last 6 years building a deterministic, static-analysis-only code review product. Earlier this year, we started thinking about this problem from the ground up and realized that static analysis solves key blind spots of LLM-only reviews. Over the past six months, we built a new \u2018hybrid\u2019 agent loop that uses static analysis and frontier AI agents together to outperform both static-only and LLM-only tools in finding and fixing code quality and security issues. Today, we\u2019re opening it up publicly.<p>Here\u2019s how the hybrid architecture works:<p>- Static pass: 5,000+ deterministic checkers (code quality, security, performance) establish a high-precision baseline. A sub-agent suppresses context-specific false positives.<p>- AI review: The agent reviews code with static findings as anchors. Has access to AST, data-flow graphs, control-flow, import graphs as tools, not just grep and usual shell commands.<p>- Remediation: Sub-agents generate fixes. Static harness validates all edits before emitting a clean git patch.<p>Static solves key LLM problems: non-determinism across runs, low recall on security issues (LLMs get distracted by style), and cost (static narrowing reduces prompt size and tool calls).<p>On the OpenSSF CVE Benchmark [1] (200+ real JS&#x2F;TS vulnerabilities), we hit 81.2% accuracy and 80.0% F1; vs Cursor Bugbot (74.5% accuracy, 77.42% F1), Claude Code (71.5% accuracy, 62.99% F1), CodeRabbit (59.4% accuracy, 36.19% F1), and Semgrep CE (56.9% accuracy, 38.26% F1). \nOn secrets detection, 92.8% F1; vs Gitleaks (75.6%), detect-secrets (64.1%), and TruffleHog (41.2%). We use our open-source classification model for this. [2]<p>Full methodology and how we evaluated each tool: <a href=\"https:&#x2F;&#x2F;autofix.bot&#x2F;benchmarks\" rel=\"nofollow\">https:&#x2F;&#x2F;autofix.bot&#x2F;benchmarks</a><p>You can use Autofix Bot interactively on any repository using our TUI, as a plugin in Claude Code, or with our MCP on any compatible AI client (like OpenAI Codex).[3] We\u2019re specifically building for AI coding agent-first workflows, so you can ask your agent to run Autofix Bot on every checkpoint autonomously.<p>Give us a shot today: <a href=\"https:&#x2F;&#x2F;autofix.bot\" rel=\"nofollow\">https:&#x2F;&#x2F;autofix.bot</a>. We\u2019d love to hear any feedback!<p>---<p>[1] <a href=\"https:&#x2F;&#x2F;github.com&#x2F;ossf-cve-benchmark&#x2F;ossf-cve-benchmark\" rel=\"nofollow\">https:&#x2F;&#x2F;github.com&#x2F;ossf-cve-benchmark&#x2F;ossf-cve-benchmark</a><p>[2] <a href=\"https:&#x2F;&#x2F;huggingface.co&#x2F;deepsource&#x2F;Narada-3.2-3B-v1\" rel=\"nofollow\">https:&#x2F;&#x2F;huggingface.co&#x2F;deepsource&#x2F;Narada-3.2-3B-v1</a><p>[3] <a href=\"https:&#x2F;&#x2F;autofix.bot&#x2F;manual&#x2F;#terminal-ui\" rel=\"nofollow\">https:&#x2F;&#x2F;autofix.bot&#x2F;manual&#x2F;#terminal-ui</a>","title":"Show HN: Autofix Bot \u2013 Hybrid static analysis and AI code review agent","updated_at":"2026-05-13T05:21:33Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"ayoub10150"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["code","review","ai","generated","bottleneck"],"value":"The modern software industry is engineering its own talent famine. In mission-critical systems programming\u2014especially within the C++ ecosystem\u2014companies are dismantling entry-level pathways while demanding senior-level proficiency from day one. By treating engineering talent purely as a resource to be acquired from the market rather than cultivated from within, corporations are creating an unsustainable knowledge vacuum that threatens the long-term maintainability of global software infrastructure.<p>This systemic breakdown is driven by four interconnected <em>bottlenecks</em>.<p>1. The Myth of the Zero-Risk Junior\nC++ sits at the foundation of critical infrastructure: autonomous systems, high-frequency trading platforms, game engines, and operating systems. Because <em>code</em> executes so close to hardware with manual memory management, companies fear that hiring inexperienced engineers introduces unmanageable stability and security risks.<p>However, this risk-averse stance ignores the foundational role of structured <em>code</em> <em>review</em> and mentorship. When senior engineers <em>review</em> junior <em>code</em>, they do not just check syntax; they evaluate systemic logic, memory lifecycles, and architecture. By treating <em>code</em> <em>review</em> as an administrative burden rather than a primary vehicle for knowledge transfer, organizations lock out developing engineers under the false assumption that entry-level hires are inherently unmanageable risks.<p>2. The Economic Short-Termism of Mentorship\nEngineering management increasingly views senior developer time through the lens of short-term feature delivery. Because supervising a junior requires context switching and time investment from senior staff, companies calculate a temporary drop in senior output as a net negative for the quarter.<p>This short-sighted economic model creates a classic free-rider problem: every company wants to hire seniors, but no company wants to invest the time required to produce them. Organizations optimize for immediate quarterly balance sheets while borrowing heavily against their future technical capacity.<p>3. The Fallacy of <em>AI</em> and Automated Tooling as Onboarding Substitutes\nTo bypass human mentorship, the industry has leaned heavily on static analyzers, dynamic sanitizers, and <em>AI</em> <em>code</em> generation. While tools like AddressSanitizer or Valgrind are essential for catching runtime violations, and <em>AI</em> models can <em>generate</em> syntax boilerplate, neither can replace senior guidance.<p>Large Language Models (LLMs) frequently <em>generate</em> syntactically convincing C++ <em>code</em> that masks subtle data races, lifetime issues, or cache-unfriendly patterns under multi-threaded loads. Relying on automated tools or <em>AI</em> output without experienced human architectural oversight leaves teams vulnerable to silent, catastrophic failures that only deep domain experience can prevent.<p>4. The Looming Senior Drought\nThe consequence of this hiring gatekeeping is an unavoidable demographic and skills crisis:<p>* Knowledge Hoarding: High-level engineering roles remain restricted to a shrinking group of veterans who entered the field when companies still trained entry-level talent.<p>* Infrastructure Fragility: Massive legacy codebases\u2014built over decades\u2014are becoming increasingly complex just as the pipeline of engineers capable of maintaining them dries up.<p>* Retirement Vacuum: As current senior architects retire or move into executive management over the next decade, companies will find a missing generation of engineers who were never given the professional environment to develop senior-level intuition.<p>The Path Forward\nResolving this crisis requires engineering leadership to recognize that seniority is an outcome of organizational investment, not a static commodity to be bought off job boards. Without dedicated onboarding pipelines, low-risk pairing models, and explicit time budgets for senior-led <em>code</em> <em>review</em>, the systems engineering ecosystem risks starving its core infrastructure of the expertise needed to sustain it."},"title":{"matchLevel":"none","matchedWords":[],"value":"Ask HR: Systems Engineering's Senior Pipeline Crisis"}},"_tags":["story","author_ayoub10150","story_50446617","ask_hn"],"author":"ayoub10150","children":[50446978,50447056,50447087,50450171,50454909],"created_at":"2026-11-10T21:33:53Z","created_at_i":1794346433,"num_comments":7,"objectID":"50446617","points":7,"story_id":50446617,"story_text":"The modern software industry is engineering its own talent famine. In mission-critical systems programming\u2014especially within the C++ ecosystem\u2014companies are dismantling entry-level pathways while demanding senior-level proficiency from day one. By treating engineering talent purely as a resource to be acquired from the market rather than cultivated from within, corporations are creating an unsustainable knowledge vacuum that threatens the long-term maintainability of global software infrastructure.<p>This systemic breakdown is driven by four interconnected bottlenecks.<p>1. The Myth of the Zero-Risk Junior\nC++ sits at the foundation of critical infrastructure: autonomous systems, high-frequency trading platforms, game engines, and operating systems. Because code executes so close to hardware with manual memory management, companies fear that hiring inexperienced engineers introduces unmanageable stability and security risks.<p>However, this risk-averse stance ignores the foundational role of structured code review and mentorship. When senior engineers review junior code, they do not just check syntax; they evaluate systemic logic, memory lifecycles, and architecture. By treating code review as an administrative burden rather than a primary vehicle for knowledge transfer, organizations lock out developing engineers under the false assumption that entry-level hires are inherently unmanageable risks.<p>2. The Economic Short-Termism of Mentorship\nEngineering management increasingly views senior developer time through the lens of short-term feature delivery. Because supervising a junior requires context switching and time investment from senior staff, companies calculate a temporary drop in senior output as a net negative for the quarter.<p>This short-sighted economic model creates a classic free-rider problem: every company wants to hire seniors, but no company wants to invest the time required to produce them. Organizations optimize for immediate quarterly balance sheets while borrowing heavily against their future technical capacity.<p>3. The Fallacy of AI and Automated Tooling as Onboarding Substitutes\nTo bypass human mentorship, the industry has leaned heavily on static analyzers, dynamic sanitizers, and AI code generation. While tools like AddressSanitizer or Valgrind are essential for catching runtime violations, and AI models can generate syntax boilerplate, neither can replace senior guidance.<p>Large Language Models (LLMs) frequently generate syntactically convincing C++ code that masks subtle data races, lifetime issues, or cache-unfriendly patterns under multi-threaded loads. Relying on automated tools or AI output without experienced human architectural oversight leaves teams vulnerable to silent, catastrophic failures that only deep domain experience can prevent.<p>4. The Looming Senior Drought\nThe consequence of this hiring gatekeeping is an unavoidable demographic and skills crisis:<p>* Knowledge Hoarding: High-level engineering roles remain restricted to a shrinking group of veterans who entered the field when companies still trained entry-level talent.<p>* Infrastructure Fragility: Massive legacy codebases\u2014built over decades\u2014are becoming increasingly complex just as the pipeline of engineers capable of maintaining them dries up.<p>* Retirement Vacuum: As current senior architects retire or move into executive management over the next decade, companies will find a missing generation of engineers who were never given the professional environment to develop senior-level intuition.<p>The Path Forward\nResolving this crisis requires engineering leadership to recognize that seniority is an outcome of organizational investment, not a static commodity to be bought off job boards. Without dedicated onboarding pipelines, low-risk pairing models, and explicit time budgets for senior-led code review, the systems engineering ecosystem risks starving its core infrastructure of the expertise needed to sustain it.","title":"Ask HR: Systems Engineering's Senior Pipeline Crisis","updated_at":"2026-11-12T11:56:45Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"broAhmed"},"story_text":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["code","review","generated","bottleneck"],"value":"Our company is changing its Software Development Lifecycle (SDLC). Curious to hear from others what theirs looks like overall + <em>bottlenecks</em>. Ours:<p>- 1 week planning/retro, 6 weeks implementation (basically six 1-week sprints).<p>- Standup now mainly demoing what Engineering/Design is working on, getting quick feedback from teammates.<p>- Meetings are recorded/transcribed. Agents <em>generate</em> Product Requirement + System Design docs from those meetings.<p>- Push to have non-engineers be able to commit <em>code</em>, but engineering still responsible for shipping it.<p>Unsolved issues/<em>bottlenecks</em>:<p>- Ephemeral test environments (per PR test environments) aren't 100% reliable yet.<p>- No longer doing capacity planning, but it feels like we need to go back to it.<p>- <em>Code</em> <em>reviews</em>. They're longer and there's more of them. Even more with non-engineers being able to @Cursor on Slack.<p>- Design used to have Figma as the source of truth; now that they're heavily leaning on Claude Design, we don't get the linkage of Figma components to <em>code</em> components. We might solve this by moving from Cursor to Claude <em>Code</em>."},"title":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["ai"],"value":"Ask HN: What's your team's SDLC look like in this <em>AI</em> world?"}},"_tags":["story","author_broAhmed","story_49275494","ask_hn"],"author":"broAhmed","children":[49275925,49281322,49282635,49333522],"created_at":"2026-08-12T17:02:20Z","created_at_i":1786554140,"num_comments":4,"objectID":"49275494","points":4,"story_id":49275494,"story_text":"Our company is changing its Software Development Lifecycle (SDLC). Curious to hear from others what theirs looks like overall + bottlenecks. Ours:<p>- 1 week planning&#x2F;retro, 6 weeks implementation (basically six 1-week sprints).<p>- Standup now mainly demoing what Engineering&#x2F;Design is working on, getting quick feedback from teammates.<p>- Meetings are recorded&#x2F;transcribed. Agents generate Product Requirement + System Design docs from those meetings.<p>- Push to have non-engineers be able to commit code, but engineering still responsible for shipping it.<p>Unsolved issues&#x2F;bottlenecks:<p>- Ephemeral test environments (per PR test environments) aren&#x27;t 100% reliable yet.<p>- No longer doing capacity planning, but it feels like we need to go back to it.<p>- Code reviews. They&#x27;re longer and there&#x27;s more of them. Even more with non-engineers being able to @Cursor on Slack.<p>- Design used to have Figma as the source of truth; now that they&#x27;re heavily leaning on Claude Design, we don&#x27;t get the linkage of Figma components to code components. We might solve this by moving from Cursor to Claude Code.","title":"Ask HN: What's your team's SDLC look like in this AI world?","updated_at":"2026-08-19T03:01:52Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"mikaelaast"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["code","review","ai","generated","bottleneck"],"value":"The term \u201ccognitive debt\u201d is gaining ground [1]. We can now produce <em>code</em> faster than we can understand it. The <em>bottleneck</em> is real, and so is the feeling of being choked.\nThe situation is not new. We have always had <em>code</em> no one quite dares to touch. Agentic coding makes it much worse.\nYou probably know the feeling. Everything can look fine. The <em>code</em> compiles. The tests are green. The pull request looks reasonable. The diff gives off a vague \u201cprobably fine\u201d vibe. But does anyone actually understand what was added?\nCongratulations: you have taken on cognitive debt.<p>Programming is about building knowledge. That used to be simpler. Until recently, the <em>code</em> itself was proof of understanding. That era is over.\nNow understanding has to be traced to something far more elusive: human mental models. Those are harder to track.\nI have previously described a kind of \u201cmind palace\u201d: an abstract model of a system where I can wander around, open and close doors, knock down a wall, add a new wing, and feel what connects to what.\nThat mental model is what lets me change <em>code</em> with confidence. It is what lets me smell that something is wrong before I have proved it.\nWhen that model is missing, things grind to a halt. Trust disappears. Changes become painful. Fear of touching anything grows. You become a tourist in your own codebase.<p>How much of your codebase is backed by human mental models? The burden of proof is on you, you trigger-happy, agent-pilled developer.\nI think we need an \u201caccounting system\u201d for cognitive debt.\nA system that can answer simple but uncomfortable questions: Who understands this <em>code</em>? At what level? Who can verify that understanding?\nThis ledger should be reconciled continuously. Everything is cognitive debt until proven otherwise. The clock is ticking.<p>I imagine microcertification: small certificates tied to concrete <em>code</em>. A file, folder, or module.\nThe certificate says: \u201cMikael has demonstrated understanding of this area, at this level, verified by this authority.\u201d\nIt should live alongside the <em>code</em>.<p>Not everyone needs the same model. That would be impossible.\nDifferent roles need different mental models. An implementer needs to demonstrate low-level understanding, while a team lead may only need a high-level model. Both models can be reconciled on their own terms.\nThe hard part is verification. How do you create \u201cproof of understanding\u201d?\nVerification has to be <em>AI</em>-resistant and rooted in something we trust: a domain expert, a tech lead, a reviewer, a pair-programming session. Anchoring it in the physical world is crucial.\nThink of it as <em>code</em> <em>review</em>, but for your mental model.<p>Imagine an append-only ledger that follows the codebase. It logs when <em>code</em> is added, changed, or removed; when understanding is certified; and when changes invalidate old understanding.\nHistory, signatures, and traceability are the key ideas, so the repo can carry its own \u201ccomprehension state\u201d with it.\nAn IOU.\nWhat should the debt be measured in? I\u2019m thinking lines of <em>code</em>.\nBefore anyone calls me out: yes, LOC is a bad measure of productivity. I know. But here we are measuring understanding.\nIf an agent spits out 2000 lines of <em>code</em>, we have not just gained 2000 lines of functionality. We have also gained 2000 lines that someone must understand, own, debug, and maintain.\nThe incentives balance out: more lines mean more debt, so the agent should not <em>generate</em> arbitrary amounts of <em>code</em>. But if you force it into cryptic <em>code</em> golf just to keep line count down, human understanding gets more expensive to build.<p>I worry we are neglecting our mental models, then pretending everything is fine.\nAgentic coding creates cognitive obligations; we need new processes to meet them.\nEvery line of <em>code</em> should be recorded as cognitive debt until certified as part of a living human mental model. Yes, that is radical. But then, we are living in absolutely bananas times.<p>[1] https://margaretstorey.com/blog/2026/02/09/cognitive-debt/"},"title":{"matchLevel":"none","matchedWords":[],"value":"Tell HN: We need an accounting system for cognitive debt"}},"_tags":["story","author_mikaelaast","story_48760460","ask_hn"],"author":"mikaelaast","children":[48827349],"created_at":"2026-07-02T12:30:56Z","created_at_i":1782995456,"num_comments":0,"objectID":"48760460","points":2,"story_id":48760460,"story_text":"The term \u201ccognitive debt\u201d is gaining ground [1]. We can now produce code faster than we can understand it. The bottleneck is real, and so is the feeling of being choked.\nThe situation is not new. We have always had code no one quite dares to touch. Agentic coding makes it much worse.\nYou probably know the feeling. Everything can look fine. The code compiles. The tests are green. The pull request looks reasonable. The diff gives off a vague \u201cprobably fine\u201d vibe. But does anyone actually understand what was added?\nCongratulations: you have taken on cognitive debt.<p>Programming is about building knowledge. That used to be simpler. Until recently, the code itself was proof of understanding. That era is over.\nNow understanding has to be traced to something far more elusive: human mental models. Those are harder to track.\nI have previously described a kind of \u201cmind palace\u201d: an abstract model of a system where I can wander around, open and close doors, knock down a wall, add a new wing, and feel what connects to what.\nThat mental model is what lets me change code with confidence. It is what lets me smell that something is wrong before I have proved it.\nWhen that model is missing, things grind to a halt. Trust disappears. Changes become painful. Fear of touching anything grows. You become a tourist in your own codebase.<p>How much of your codebase is backed by human mental models? The burden of proof is on you, you trigger-happy, agent-pilled developer.\nI think we need an \u201caccounting system\u201d for cognitive debt.\nA system that can answer simple but uncomfortable questions: Who understands this code? At what level? Who can verify that understanding?\nThis ledger should be reconciled continuously. Everything is cognitive debt until proven otherwise. The clock is ticking.<p>I imagine microcertification: small certificates tied to concrete code. A file, folder, or module.\nThe certificate says: \u201cMikael has demonstrated understanding of this area, at this level, verified by this authority.\u201d\nIt should live alongside the code.<p>Not everyone needs the same model. That would be impossible.\nDifferent roles need different mental models. An implementer needs to demonstrate low-level understanding, while a team lead may only need a high-level model. Both models can be reconciled on their own terms.\nThe hard part is verification. How do you create \u201cproof of understanding\u201d?\nVerification has to be AI-resistant and rooted in something we trust: a domain expert, a tech lead, a reviewer, a pair-programming session. Anchoring it in the physical world is crucial.\nThink of it as code review, but for your mental model.<p>Imagine an append-only ledger that follows the codebase. It logs when code is added, changed, or removed; when understanding is certified; and when changes invalidate old understanding.\nHistory, signatures, and traceability are the key ideas, so the repo can carry its own \u201ccomprehension state\u201d with it.\nAn IOU.\nWhat should the debt be measured in? I\u2019m thinking lines of code.\nBefore anyone calls me out: yes, LOC is a bad measure of productivity. I know. But here we are measuring understanding.\nIf an agent spits out 2000 lines of code, we have not just gained 2000 lines of functionality. We have also gained 2000 lines that someone must understand, own, debug, and maintain.\nThe incentives balance out: more lines mean more debt, so the agent should not generate arbitrary amounts of code. But if you force it into cryptic code golf just to keep line count down, human understanding gets more expensive to build.<p>I worry we are neglecting our mental models, then pretending everything is fine.\nAgentic coding creates cognitive obligations; we need new processes to meet them.\nEvery line of code should be recorded as cognitive debt until certified as part of a living human mental model. Yes, that is radical. But then, we are living in absolutely bananas times.<p>[1] https:&#x2F;&#x2F;margaretstorey.com&#x2F;blog&#x2F;2026&#x2F;02&#x2F;09&#x2F;cognitive-debt&#x2F;","title":"Tell HN: We need an accounting system for cognitive debt","updated_at":"2026-07-08T04:04:24Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"evolve2k"},"title":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["review","ai","bottleneck"],"value":"Study on <em>AI</em> coding agents finds gains \"absorbed\" by human <em>review</em> \"<em>bottleneck</em>.\""},"url":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["code","ai","generated"],"value":"https://arstechnica.com/<em>ai</em>/2026/10/<em>ai</em>-coding-agents-<em>generate</em>-more-<em>code</em>-but-not-more-software/"}},"_tags":["story","author_evolve2k","story_50030717"],"author":"evolve2k","children":[50030738,50031812,50032721,50032804,50056658],"created_at":"2026-10-10T07:55:10Z","created_at_i":1791618910,"num_comments":3,"objectID":"50030717","points":9,"story_id":50030717,"title":"Study on AI coding agents finds gains \"absorbed\" by human review \"bottleneck.\"","updated_at":"2026-10-12T14:12:06Z","url":"https://arstechnica.com/ai/2026/10/ai-coding-agents-generate-more-code-but-not-more-software/"}],"hitsPerPage":20,"nbHits":23,"nbPages":2,"page":0,"params":"query=code+review+AI+generated+bottleneck&tags=story&advancedSyntax=true&analyticsTags=backend","processingTimeMS":25,"processingTimingsMS":{"_request":{"queue":1,"roundTrip":19},"afterFetch":{"format":{"highlighting":2,"total":3}},"fetch":{"query":14,"scanning":9,"total":24},"total":25},"query":"code review AI generated bottleneck","serverTimeMS":30}
