Human Takeoff and Landing Model
Let humans set direction and verify the landing while AI handles execution.
- Difficulty
- Easy
- Time to result
- ~days to results
- Steps
- 4
- Confidence
- 95%
The Human Takeoff and Landing Model treats AI execution like an automated flight. The human takes off by choosing the problem, deciding the destination, and supplying enough context for the agent to act. The AI handles the middle: finding files, writing routine code, and preparing a proposed change. During that work, the human monitors whether the route still fits the system's architecture rather than rewriting every line. The human then lands the work through functional checks, tests, and review by the teammate who owns the affected area. This shifts scarce attention away from syntax and toward direction, architecture, and acceptance. It also creates a simple accountability boundary: an agent may draft the change, but a person remains responsible for deciding that it is safe and correct.
Origin
Sahil used the plane analogy while reviewing a Devin pull request for Gumroad's AI-generated weekly Slack recap and deciding what still required human judgment.
Core principles
- 01Humans own the problem, destination, and acceptance criteria
- 02AI can perform most of the mechanical work between intent and review
- 03Architecture and system context matter more as code generation gets cheaper
- 04Tests and human QA convert a plausible output into a trustworthy result
How to run it
- 1
Take off with intent
Define the problem, desired destination, and key constraints before the agent starts. The human owns why the change exists and what success looks like.
Pro tip Describe observable output, not merely the code you expect to change.
Watch out An unclear destination makes even excellent execution unreliable.
- 2
Let AI fly the middle
Delegate repository exploration, routine implementation, and pull-request preparation to the agent. Avoid spending human time reproducing mechanical work the agent can complete.
Pro tip Run bounded tasks asynchronously so human attention can move to another decision.
- 3
Check the route
Inspect whether the approach fits the surrounding architecture and standards. Focus on the system-level decision rather than line-by-line syntax that the agent generally handles well.
Pro tip Use tests as an independent signal that the selected route matches existing behavior.
Watch out Good local code hygiene does not guarantee the right architectural choice.
- 4
Land with human QA
Run the product, review the behavior, and ask the appropriate teammate to confirm the pull request and test coverage. Merge only when a person accepts responsibility for the result.
Pro tip Hand reviewers a mostly completed change so their time goes into validation rather than construction.
Watch out Never replace acceptance testing with confidence in the agent's reasoning trace.
In the wild
Sahil asked Devin to improve a weekly Slack recap so it emphasized real shipments and hid empty projects. Devin located both the generation prompt and a code filter, then produced a pull request. Sahil inspected the approach but did not treat that inspection as sufficient; he planned to send it to the responsible teammate to verify the result and identify any missing tests.
→ The agent completed most of the implementation while the human review stayed focused on architecture, behavior, and test coverage.
Common mistakes
Delegating the destination
The agent should not decide which customer problem matters or what outcome the business needs. Those are takeoff decisions owned by people.
Reviewing syntax instead of the system
When generated code is locally tidy, the higher-value human check is whether the architecture, behavior, and test strategy are correct.
Skipping the landing check
A completed pull request is not a completed outcome. The running product and relevant tests must confirm that the change works.
Is it for you?
Best for
Teams delegating implementation work to coding agents while retaining human accountability for product and system quality.
Not ideal for
Tasks where the human cannot define success or independently inspect the result.
From the episode
Announcing a brand-new podcast: “How I AI” with Claire Vo 🔥