Key Takeaways

  • Greptile raised a $50 million Series B led by Menlo Ventures to build independent, automated code testing and validation software.
  • Enterprise engineering teams at companies like Nvidia refuse to allow code generation models to approve or merge their own pull requests.
  • Engineering leaders apply intense scrutiny to hiring a developer for $250,000 per year, but let AI coding agents run up uncontrolled token bills without measuring bug rates.
  • True code validation requires a structural separation of concerns between the model writing code and the system checking whether that code is safe to ship.

Never Let the Model Grade Its Own Homework

Software teams are flooding repositories with automated pull requests. Coding agents can draft features, patch edge cases, and spit out thousands of lines of syntax in seconds. Yet the moment code hits production, blind trust creates systemic failure.

Daksh Gupta, founder and CEO of Greptile, points out that the biggest engineering organizations in tech draw a hard boundary at automated approvals. Enterprise teams like Nvidia will not allow the same model family that drafted a pull request to decide if that pull request belongs in main.

“We wanted our validation to be separate,” Gupta explains. “We wanted the separation of concerns between the thing that's writing the code and the thing that's merging and reviewing and approving the code.”

If you ask an LLM to review the code it just generated, you run into confirmation bias baked into the model weights. The generator repeats its own blind spots. It hallucinates an interface, writes a test based on that hallucinated interface, passes its own test, and flags the pull request as clean. Greptile raised $50 million from Menlo Ventures specifically because enterprises demand an adversarial layer: an outside engine designed exclusively to prove the code change broken before human beings ever see it.

Gupta defines the core product goal in plain terms: “trying to automate code validation which to us means that we want to make it so that you can review and test any code change and for sure know it is safe to merge.”

The Reckless Blind Spot in Token Spend

While companies race to adopt automated coding assistants, almost nobody measures the actual output. Engineering executives audit headcounts for months. A manager must build a multi-page business case, run three interview loops, and secure executive approval to hire an engineer at a $250,000 annual salary. But that same manager will hand credit cards to an entire team to run LLM inference agents with zero tracking.

“When you think about the relative scrutiny of hiring another person for quarter million a year,” Gupta says, “we've put a lot more thought into whether we should hire another person for quarter million then we just like let the coding agent math just rip.”

This lack of observability cannot last. Teams currently rack up compute bills without knowing if their pull request cycle times actually improved, whether production incidents spiked, or if code churn increased.

“I can't imagine that we'll keep spending these large quantities and then just be okay with the fact that there isn't measurable downstream increase in productivity or quality or something,” Gupta notes.

Throwing compute at developer velocity works only if you can track what that compute buys. If half your AI-generated code introduces logic errors that senior engineers spend three hours debugging during reviews, your net velocity dropped.

What to Do With This

Audit your team's pull request workflow this week. Check your last 20 merged pull requests written with AI assistance, and calculate how many required immediate follow-up bug fixes within 48 hours. Then, block any workflow where an AI agent reviews or auto-approves code written by the same model family.