Evaluating AI Coding Models for Long-Running Coding Tasks: Real-World Testing and a Permission Acceptance Checklist
This article moves beyond leaderboard scores to examine how AI coding models perform on long-running, production-style software tasks. Through two contrasting projects—an incremental change to an existing cross-platform motion platform and a new learning game built from minimal materials—it shows why functional correctness and passing automated tests are not enough. The key risk is authorization, especially object-level access control and IDOR-style vulnerabilities that appear when models do not recognize implicit permission boundaries. It also provides practical guidance for test design, cross-user and role-based checks, automated security gates, manual acceptance lists, and tiered autonomy for teams adopting AI-assisted coding in production.
Beyond the leaderboard: How to evaluate long-running coding tasks
When teams discuss next-generation AI coding models, the first questions are often about scores: how much have terminal-task benchmarks, software engineering benchmarks, and general reasoning benchmarks improved?
But once the model enters a real project, the questions become more practical:
- How should long-running coding tasks be evaluated?
- Can the model understand tens of thousands of lines of code and make progress across multiple modules?
- What are the common causes of permission vulnerabilities?
- What should be included in an acceptance checklist before the model is allowed into the project?
Leaderboards usually answer one question: can the model write code? Engineering needs to answer a different one: can the model complete a task end to end, and does it avoid leaving hidden risks that surface during acceptance?
There are four gaps between those two questions:
- Context understanding
- Long-running task execution
- Verifiability
- Built-in security
Public materials about newer AI coding models generally state that the base model has not undergone a fundamental replacement. Improvements are said to come mainly from post-training, including more real-task environments, more diverse environment types, and longer training time. Because this article does not have complete source materials for specific model versions, release dates, training environment multipliers, or measurement standards, it avoids absolute numbers and does not claim that any model is “the strongest.” Instead, these claims should be treated as directional background.
For engineering teams, the more important question is how to verify these capabilities through reproducible workflows.
Test design: using two projects to evaluate delivery capability
To reduce dependence on isolated examples, this article uses two very different projects for comparison.
Project 1: Incremental development on an existing system
Project 1 was an incremental upgrade to an existing cross-platform motion platform.
- Team size: about 6 people
- Repository size: about 48,000 lines of code
- Existing assets: 38 API endpoints, 213 automated tests, and prior security audit records
The task was to add secure image asset import, persistent storage, and HTML animation references without breaking existing logic.
Project 2: Building a learning game from scratch
Project 2 was a new learning game built from minimal input.
- Input: one piece of agent learning material and a requirements document
- Final output: about 12,000 lines of code
- Acceptance: 126 test cases
In both projects, the evaluation did not focus only on whether the model generated code. It recorded:
- Session duration
- Number of manual takeovers
- Number of build failures
- Test pass rate
- Defect severity
- Final acceptance conclusion
Acceptance for Project 1 included functional testing, security auditing, and manual privilege-escalation testing. Acceptance for Project 2 included a complete playthrough, exception-flow testing, and code review.
Project 1: Passing tests does not mean ready to deliver
The model performed as expected in a long-running coding task. It was able to:
- Identify module boundaries from existing code
- Understand existing data-access patterns
- Follow the repository’s API style and error-handling conventions
- Make cross-layer changes
- Build, test, and fix errors after implementation
In the end, the feature worked, and the automated test suite passed.
However, manual acceptance revealed a P1 permission-isolation defect: users could access or reference image assets that did not belong to them.
This was not a case of the model being unable to write permission checks. The issue was that it did not recognize the permission boundary.
Flawed example
async def get_asset(asset_id: str, user: User = Depends(current_user)):if not user.is_active:raise HTTPException(status_code=403, detail="forbidden")asset = await asset_repo.find_by_id(asset_id)if asset is None:raise HTTPException(status_code=404, detail="not found")return asset
This code checks whether the user is logged in and active. However, it queries the asset only by primary key. If an attacker changes asset_id, they may be able to read another user’s asset.
This is an object-level authorization problem, commonly known as an IDOR vulnerability: Insecure Direct Object Reference.
Corrected example
async def get_asset(asset_id: str, user: User = Depends(current_user)):asset = await asset_repo.find_by_id_and_owner(asset_id, owner_id=user.id)if asset is None:raise HTTPException(status_code=404, detail="not found")return asset
The corrected version moves ownership filtering into the query itself. It also avoids distinguishing between “asset does not exist” and “asset does not belong to you,” reducing the risk of revealing whether an asset exists.
The model often understands “secure import” as file safety: extension checks, magic-number checks, size limits, file renaming, and directory isolation.
But “a resource returned by an API must belong to the current user” is an implicit permission boundary. That boundary is usually scattered across business rules, data models, and role design. This is why a model may be capable of white-box code review and still miss privilege-escalation combinations from an attacker’s perspective.
Why passing tests did not catch the issue: add privilege-escalation cases to assertions
The model’s self-tests covered the implementer’s path, not the attacker’s path.
Teams should add cross-user privilege-escalation tests:
- Prepare User A and User B.
- User A uploads an asset and records its
resource_id. - User B logs in and requests that resource.
- Check direct endpoints and indirect endpoints, such as details, references, exports, and sharing.
Suggested assertion template:
- When User B requests a resource owned by User A, the API should return
404or403. - The response body must not contain resource metadata.
- The API should not return a message such as “you do not have permission” if that message reveals the existence of the resource.
- Logs must not output complete sensitive identifiers.
- A low-privilege account accessing an administrative API must be rejected.
These tests move authorization checks from optional human review into repeatable automated validation.
Project 2: From materials to product: exception boundaries still need human input
Project 2 showed the model’s ability to turn source material into product design, manage state and workflows, and verify end-to-end behavior.
The model could convert the provided material into:
- Game levels
- Scoring logic
- Progress tracking
- A completable main gameplay flow
However, exception cases exposed gaps:
- Progress was not saved if the user exited midway
- Repeated submissions could overwrite state
- Empty inputs, oversized inputs, and corrupted files lacked fallback handling
- Error feedback was unclear
These issues did not block the demo, but they affected product completeness.
The conclusion is clear: for tasks with well-defined goals, a model can take on a large amount of implementation work. But exception flows, data boundaries, and extensibility still require human input.
Why long-running capabilities require shifting security left
The stronger a model’s long-running capabilities, the larger the impact of a single security defect.
A change spanning dozens of files and APIs can introduce multiple missing ownership checks. If a few endpoints fail to validate ownership, the defect can spread across the entire system.
When functionality works, tests pass, and the demo looks smooth, permission problems are often invisible. They may only become obvious after deployment.
When evaluating new AI coding models, teams should not ask only:
How much work can the model do?
They should also ask:
If the model makes a mistake, can our process detect it?
Reusable evaluation and acceptance methods
Five-layer evaluation framework
Context understanding
Check whether the model identifies the correct change points, affected callers, and implicit dependencies.Long-running progression
Check whether the model can continue working over multiple steps and correct itself when needed.Verifiability
Check whether builds, tests, and critical user flows pass.Built-in security
Check whether permission matrices are covered and whether high-risk warnings appear.Delivery consistency
Check whether naming, layering, error handling, and logging follow project conventions.
The first two layers determine whether the model can be used. The last three layers determine whether the team can safely deliver the result.
Recommended automated gates
- Before commit: run local static checks.
- During merge request review: enforce privilege-escalation rules, path-handling checks, and upload validation.
- During testing: run cross-user, cross-project, and cross-role test cases.
- Before release: perform manual security review.
Teams can integrate these checks with static application security testing, dependency scanning, rule engines, and dedicated privilege-escalation test suites.
Suggested failure thresholds:
- Block merge: unauthenticated routes, high-risk privilege escalation, path traversal, and high-risk upload issues
- Require fix or approved exception: medium-severity issues
- Record and schedule: low-severity issues
Manual acceptance checklist
Manual acceptance should cover:
- Horizontal privilege escalation
- Vertical privilege escalation
- Object-level authorization
- File handling
- Default-deny behavior
- Information leakage
Teams should also test indirect entry points, such as:
- Bulk export
- Search
- References
- Sharing
These endpoints often expose the same object-level authorization flaw, even when the main detail API is protected.
Deployment recommendations: tiered autonomy and process alignment
Teams can allow models to handle more implementation work on low-risk tasks.
However, logic related to permissions, security, and sensitive data should be designed and accepted by humans.
At the process level, security should be shifted left into automated gates and review checklists.
Deployment should also be evaluated carefully:
- Open-weight versions of newer models should be deployed based on official security assessments and hardening progress.
- In cloud environments, teams can combine model services, container platforms, object storage, log monitoring, and unified access auditing to build a closed loop covering development, testing, deployment, and production monitoring.
Ultimately, model capability determines how much work can be done. Engineering process determines how much of that work can be safely delivered.
Only when the two match is long-running AI-assisted coding ready for production use.
