ReadingResearchRadarInvestment framework
Sign in / Sign up
← Back to reading
NewsMaterial3 min readDisconfirmAI Editorial

Tetsuya Shinchi, Head of Cloud Development at Japanese Cloud Company grasys: Shifting the Human-in-the-Loop Bottleneck from Code Review to Test Case Approval

Tetsuya Shinchi, head of cloud development at Japanese cloud infrastructure company grasys, describes a specific method for addressing the bottleneck where AI code generation outpaces human review capacity: before generating implementation code, have the AI generate test cases based on GitHub Issues, which engineers then review and approve as 'executable requirement definitions.' The AI then autonomously implements the solution within this approved framework and self-corrects. This shifts the Human-in-the-Loop checkpoint from downstream code review to upstream test case approval, concentrating human intervention on requirement alignment rather than line-by-line inspection.

2026-10-26 08:25 GMT+8

Tetsuya Shinchi is the Head of Cloud Development at grasys, a Japanese cloud infrastructure company. He joined the company in April 2024, overseeing internal infrastructure development and operations development for large-scale client systems. In an interview with gihyo.jp, a technical publication by Technical Review Corporation (Japan), he described a bottleneck commonly faced by AI-driven development teams today: the speed at which AI generates code far exceeds the ability of engineers to understand and confirm it. This leads to situations where engineers submit Pull Requests without truly understanding the logic, simply because the code runs locally. Shinchi listed specific problems arising from this, such as superficial fixes during refactoring, functions deleted in one place but left unhandled elsewhere, multiple unrelated operations mixed into a single function, and a lack of comments intended for human readers. He attributes the root cause to the fact that those using AI often do not clearly define what they want the AI to do.

grasys addresses this by shifting the human review checkpoint from code review to test case approval. The specific workflow is as follows: An engineer creates a GitHub Issue written in Japanese—structured for easy AI comprehension (e.g., 'Implement product search functionality for the demo e-commerce site')—and instructs the AI to create a feature branch starting from develop and begin a Test-Driven Development (TDD) process according to a tdd-playbook. The AI first autonomously generates a framework for test cases based on the Issue content. At this stage, the process pauses pending human approval. Engineers review not the generated implementation code, but the specifications and logic of these test cases defined in Japanese, confirming that the scope the AI intends to implement aligns with human expectations. If the test cases fully match business requirements, they are committed to the repository as an 'absolute correct framework,' and the AI is notified to begin implementation.

Sign in / Sign up
ReadingResearchRadarInvestment framework

The mechanism behind this design is that test cases are smaller and more focused on requirements themselves, making them easier for humans to verify quickly and accurately. Once the test framework is established, if the AI makes temporary errors during the implementation phase, it can discover and correct them autonomously by running tests, without requiring engineers to reissue instructions each time. Shinchi refers to this approach as 'shift-left' (シフトレフト), moving the Human-in-the-Loop checkpoint from downstream code review to upstream test case approval. The result is that when engineers finally perform code review, the implementation has already passed all tests, eliminating rework (手返) and simultaneously alleviating the subjectivity issues inherent in code reviews.

However, Shinchi explicitly points out another aspect this method cannot fully resolve: junior engineers may lose the opportunity to build deep 'mental models.' Previously, engineers built their understanding of system internals by repeatedly consulting official documentation, debugging error messages, and painstakingly troubleshooting. This process is now significantly abbreviated, creating a state where 'even if the internal structure is a black box, things just run if you hand them over to AI.' He considers this a challenge for future talent development, but grasys's current strategy is to set necessary safety boundaries at the organizational level (such as IAM permission inheritance and ensuring AI cannot access data the engineer personally lacks permission to view) while granting maximum discretion to field engineers within those boundaries, allowing each individual to judge which parts should be delegated to AI and which must be confirmed manually.

Sources

  • gihyo.jp↗
Continue researching →