Adaptive Execution Planner

About the Project

Adaptive Execution Planner turns goals into realistic, dependency-aware schedules and helps users recover when their plans fall behind.

Traditional task managers can show what needs to be done, but they often leave users to figure out how to recover when deadlines slip. Adaptive Execution Planner takes a constraint-aware approach: it considers task dependencies, available daily hours, deadlines, and completed work before proposing a revised schedule.

Instead of blindly moving unfinished tasks around, the planner checks whether a valid schedule actually exists and explains the obstacles when it does not.

Inspiration

I wanted to solve a problem that students and independent builders encounter regularly: a plan can look perfectly reasonable at the beginning of a project, but one missed task can disrupt everything that depends on it.

Most simple planners track tasks and dates without explaining whether the remaining work can realistically fit into the time available. I wanted to build a planner that treats scheduling as a real constraint problem, not just a list of tasks with new dates.

What It Does

Adaptive Execution Planner provides an end-to-end workflow for planning and recovering from disruptions.

• Goal setup: Define a project, deadline, daily availability, milestones, and tasks.
• Automatic scheduling: Generate a schedule that respects task dependencies and available capacity.
• Progress tracking: Complete tasks, monitor progress, and identify overdue work.
• Dependency awareness: Show when unfinished prerequisite tasks block downstream work.
• Honest feasibility checks: Distinguish aggregate capacity shortfalls from dependency bottlenecks that prevent a valid schedule.
• Recovery proposals: Preview options such as increasing daily availability, extending the deadline, or reducing scope.
• Review before applying: Inspect the proposed schedule changes and cancel without changing the existing plan.
• Revision history: Apply a revised plan and preserve a record of changes.

The application uses a deterministic scheduling engine, so its feasibility assessments and recovery proposals follow explicit rules rather than relying on a language model to invent a schedule.

How We Built It

I used the Devpost Learn Skill Pack with an AI coding agent to guide the project from initial scoping through implementation and shipping.

The workflow covered project scope, product requirements, technical specifications, incremental implementation, testing, and final documentation.

The application uses Next.js, React, TypeScript, and Tailwind CSS. React Context and useReducer manage planner state, while a pure TypeScript scheduling engine handles task allocation, dependency constraints, feasibility diagnostics, and replanning previews. Local storage preserves the user's plan between sessions.

I built the application in four incremental implementation slices, validating the scheduling logic and user-facing behavior as the product developed. The repository includes the planning documents, source code, automated tests, setup instructions, and an MIT license.

Challenges We Faced

One of the central challenges was distinguishing a plan with enough total available hours from a plan that can actually be scheduled.

A project may have sufficient aggregate capacity but still be infeasible because a chain of dependent tasks cannot fit into the remaining days. Increasing daily availability does not necessarily solve that problem.

Another challenge was making replanning safe and understandable. Users need to see the consequences of a proposed recovery before committing to it. The preview therefore evaluates changes without mutating the existing plan, and the user explicitly confirms the revision.

Testing these edge cases and preserving completed work and revision history were important parts of making the planner dependable.

Accomplishments

• Built a working goal-to-schedule-to-recovery workflow.
• Implemented deterministic task scheduling with dependency and capacity constraints.
• Added distinct feasibility diagnostics for capacity shortfalls and dependency bottlenecks.
• Built a reviewable replanning interface with multiple recovery strategies.
• Preserved completed tasks and revision history through replanning.
• Added automated tests covering the scheduling engine, state management, persistence, dashboard behavior, and replanning.
• Finished with 27 passing automated tests, a clean TypeScript check, and a successful production build.

What We Learned

I learned to turn a broad product idea into a constrained, testable specification before implementing the interface.

The project reinforced the value of keeping scheduling logic pure and separate from UI state, writing explicit invariants, and testing failure cases rather than only happy paths.

I also learned that an AI coding agent is most useful when guided through a structured process with clear requirements, incremental implementation, human review, and verification. A working interface is only part of the result; the underlying behavior must also be explainable and testable.

What's Next

Future iterations could explore calendar integrations, richer project templates, and more flexible scheduling. The current proof of concept focuses on deterministic scheduling, transparent recovery decisions, and reliable local persistence.

Built With

• css
• html
• next.js
• react
• tailwind
• typescript
• vitest