Our engineering team recently participated in a 72-hour development challenge organized by the innovation unit of a global electronics company.
The assignment was to build a working application using New York City's publicly available building-energy data. Each participating company had to define its own product, users, and implementation approach.
We delivered a live proof of concept (PoC) that analyzes energy consumption across approximately 30,000 commercial buildings, identifies underperforming properties, and generates recommendations with estimated improvement costs and payback periods.
The project involved six people, including four engineers, a business analyst, and a UX designer. Three engineers worked throughout the build, with a fourth joining on the final day.
Seven AI agents handled implementation, code review, and fixes within a workflow we had already been developing at MEV.
By the end of the challenge, the team had merged approximately 127 pull requests, spent around 107 human working hours, and deployed an application with a basic infrastructure cost of $45 per month.
The project received first place in the organizer's code-quality and AI-integration assessments.
Here's how we organized the development process, where the agents were useful, and which decisions remained with the engineers.
Defining a product before writing code
The initial brief provided access to data collected under New York City's Local Law 84, which requires certain buildings to report their annual energy consumption.
The dataset contained information on approximately 30,000 buildings.
It could support several types of applications, from individual building-performance dashboards to portfolio-level energy analysis.
We spent the first morning defining one specific user.
Our target was a Building Performance Analyst responsible for energy performance across a portfolio of commercial properties.
This person needs to identify underperforming buildings, investigate potential improvements, and present recommendations to management.
That user definition shaped the application.
A basic dashboard showing energy consumption would provide useful information, but the analyst also needed to explain why a particular building deserved attention and what improvements might cost.
We therefore focused on three capabilities:
- Compare a building's energy performance against similar properties.
- Generate improvement recommendations with estimated costs and payback periods.
- Allow users to ask questions about building data in natural language.
While the business analyst and UX designer worked through the user journey, engineers prepared the infrastructure and development environment.
By limiting the application to one primary user, we could test the complete flow from raw data to a recommendation within the challenge's time limit.
How we organized seven AI agents
Our development process used seven specialized AI agents running through Claude Code.
Each agent had a specific responsibility. Their behavior was defined in written specifications stored alongside the application code and maintained under version control.
The agents operated as part of the MEV Innovation Lab Delivery System, an internal workflow that coordinates AI-assisted implementation, reviews, and fixes.
The core sequence looked like this:
GitHub Issue | v Architect Agent | v Engineer reviews and approves plan | v Builder Agent | v Review and specialized checks | v Fixer Agent | v Engineer approves final changes | v Merge and deployment The workflow included an architect, builder, reviewer, and fixer, along with specialized checks for security, design, and release readiness.
An engineer could start the chain with a command referencing an existing ticket:
/dev <ticket-number> The agents then processed the task through planning, implementation, review, and correction.
This reduced the amount of manual coordination required between individual development steps.
Human approval remained part of the workflow
We established two mandatory human approval points.
The first came after the architect agent prepared an implementation plan. An engineer reviewed the proposed scope and approach before allowing the agents to generate code.
The second came after the automated review and correction stages. An engineer examined the final changes before approving the merge.
The agents handled much of the work between those points.
We also ran review chains locally before opening pull requests. Reviewer and security agents identified issues and categorized findings by severity, from P0 through P4.
That gave engineers a set of findings to evaluate rather than requiring them to discover every potential issue manually.
The implementation and review stages were automated, while responsibility for architecture and accepting code remained with the engineering team.
Preparing the delivery pipeline before the first ticket
The agents needed an environment where their output could be integrated and tested quickly.
We prepared hosting on DigitalOcean and configured GitHub Issues to work directly with the agent workflow.
Deployment was automated. After changes were merged, the application deployed without a separate manual release process.
Database migrations used a separate job triggered after the relevant merge.
This preparation mattered because frequent code changes were expected. During a 72-hour build, manual deployments and repeated environment setup would consume time needed for implementation and verification.
We also kept the agent specifications in version control.
That allowed the team to maintain the workflow definitions alongside the code being developed.
What did AI code review save?
The team merged approximately 127 pull requests during the challenge.
Based on an estimate of at least 30 minutes for conventional human review per pull request, we calculated that the automated review chain replaced close to 60 hours of manual review effort.
This is an estimate based on review volume and assumed review time, rather than a measured reduction in the project's elapsed delivery time.
Human approval still happened before merging.
The benefit was that engineers could review changes after automated agents had already examined the implementation, identified potential problems, and attempted corrections.
The team could then concentrate on the issues that needed engineering judgment.
Our engineering manager, Ivan Makarov, estimated that roughly 90% of the team's time went into planning and testing.
That included identifying edge cases and preparing tests before giving implementation tasks to the agents.
AI-generated code could handle an expected workflow quickly. The engineers had to account for missing fields, unexpected inputs, and interactions between application components.
For this project, the ability to specify and evaluate the work was as important as generating the code.
The difficult work remained in the architecture
The application had to process approximately 300 MB of New York City building-energy records.
Loading that data without losing records or overwhelming the application required attention to ingestion and database behavior.
Performance mattered because users needed to move around a map and compare buildings interactively.
The calculations used to rank individual buildings against comparable properties had to return results quickly enough to support that workflow.
Each senior engineer owned a vertical part of the application, including the associated architectural decisions.
That ownership reduced handoffs when implementation revealed problems requiring immediate decisions.
For example, the engineers designed the application's behavior for cases when the external AI provider was unavailable.
If the model API failed or returned a rate-limit error, the map and building comparisons remained usable. The recommendation area displayed a notice instead of causing the entire page to fail.
The team also prepared database migration controls to support repeatable deployments.
These were engineering decisions made alongside implementation, rather than tasks delegated entirely to coding agents.
Reducing model calls with a three-stage recommendation process
The application uses AI to suggest energy-efficiency improvements for individual buildings.
Sending every request directly to an LLM with the entire dataset would create unnecessary model usage.
We designed the recommendation workflow in three stages.
Stage 1: Identify comparable buildings
The application uses statistical analysis to find buildings with similar characteristics.
This establishes the context needed to interpret a property's energy performance.
Stage 2: Retrieve relevant improvement options
The system consults a stored library of energy-efficiency measures to identify suitable improvements.
For the PoC, we loaded three upgrade options drawn from US Department of Energy guidance.
The application architecture supports a larger library, but populating hundreds of measures was outside the challenge scope.
Stage 3: Generate the recommendation
Only the final stage calls Claude.
The model receives the selected building context and relevant improvement options, then generates a recommendation adapted to the property.
This limits the role of the LLM to the part of the workflow where language generation adds value.
Statistical comparison and retrieval happen before the model request.
The approach also reduces the amount of information the model needs to process for each recommendation.
Keeping the infrastructure cost at $45 per month
The PoC ran on a small DigitalOcean setup.
Our reported monthly infrastructure breakdown was:
| Component | Monthly cost |
|---|---|
| API hosting | $25 |
| Database migration service | $5 |
| Database | $15 |
| Total | $45 |
This figure represents the basic application infrastructure used for the PoC.
Development costs were separate. Four engineers used Claude Code subscriptions priced at $200 per month each.
The $45 monthly figure should also be understood in the context of the PoC's workload and configuration. A production application with substantial traffic, a larger data pipeline, and greater AI usage would require a separate cost assessment.
We also implemented a subscription billing structure using Stripe.
The application had two subscription tiers, with the user's plan checked before each AI request.
The pricing was provisional, but the workflow demonstrated how AI consumption could be controlled by subscription limits.
Model calls were logged with information that allowed us to trace the prompt version, generated recommendation, and associated cost.
That provides a starting point for monitoring AI usage and investigating output behavior.
What we deliberately left out
A three-day delivery window forced us to decide which capabilities were essential to demonstrating the product.
We made several scope decisions early.
One city was enough
The dataset already contained approximately 30,000 New York City buildings.
Adding another city would have increased integration and data-processing work without contributing much additional evidence that the core application functioned.
We concentrated on the available dataset.
Three improvement measures were enough for the recommendation engine
The longer-term design anticipated a library containing hundreds of building-efficiency measures.
For the PoC, we used three options to test the complete process: retrieve relevant measures, analyze a building, and produce an improvement recommendation.
Adding more options would mostly have increased content preparation work.
Existing UI components were sufficient
We used existing interface components instead of investing time in custom interface development.
The UX work focused on making the analyst's workflow usable and connecting the screens to the underlying functionality.
Those choices allowed the team to complete a working application while keeping the scope aligned with the challenge.
Can this AI-agent workflow scale beyond a 72-hour PoC?
The workflow used in this project was a deliberately simplified version of our broader agent-assisted engineering process.
Its underlying pattern can be applied to longer projects: divide work into defined tasks, use specialized agents, automate verification, and require engineers to approve plans and final changes.
However, the exact configuration from this experiment would need to evolve for a larger, long-running application.
A mature project introduces additional requirements around context management, test coverage, dependencies between tasks, review depth, and changes to existing code.
The seven-agent setup demonstrated that a small senior team could coordinate a high volume of implementation work within a limited period.
It did not establish that every project can be delivered with the same team size, review process, infrastructure, or timeline.
Similarly, the completed application was a working PoC with functioning deployment, data processing, recommendations, and billing integration. Further scaling and production-readiness work would be required before serving substantial commercial traffic.
What we learned from the 72-hour build
The experiment gave us a useful measure of how agent-assisted engineering can work when the delivery process has already been established.
The result was a live application analyzing approximately 30,000 buildings, developed over three days with about 107 hours of human effort and approximately 127 merged pull requests.
The agent workflow reduced the amount of implementation and preliminary review work engineers had to perform manually.
Much of the human effort went into defining the product, designing the architecture, identifying edge cases, testing the application, and approving the results.
Several decisions contributed to the delivery speed: one well-defined user, a limited feature set, an existing agent workflow, automated deployment, and senior engineers who could take ownership of entire application components.
We now apply these principles through the MEV Innovation Lab, where engineering teams build and validate early product concepts, test technical feasibility, and develop working proofs of concept.
The seven agent specifications used for this experiment are also publicly available through MEV's GitHub resources.
The 72-hour build demonstrated what this approach could deliver under tightly controlled scope and with an experienced team. The next engineering challenge is adapting the workflow to larger codebases, longer development cycles, and the quality requirements of sustained production use.
This article is based on the MEV engineering team's 72-hour development challenge and the AI-agent workflow used during the project.
Original article: How MEV Shipped a PoC in 72 Hours With AI Agents

![Physical AI Engineering — Ch.10: Medical and Human Centric Physical AI [EN]](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvy8fkq2vnw6ud8c0kvic.png)
![Physical AI Engineering — Ch.09: Industrial Physical AI [EN]](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F2ulspenbbtgxps8mti74.png)
![Physical AI Engineering — Ch.08: Autonomous Vehicles and Mobility [EN]](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fudcokq8k14p8ppu1mdnf.png)
![Physical AI Engineering — Ch.06: Control and Actuation [EN]](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgqtcsihzvvie5v9x4dzo.png)
![Physical AI Engineering — Ch.05: Decision Making and Reasoning [EN]](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fanmj7rqd1d7j07dzk4yv.png)