ACComplish

Study online. Stay on line.

Comment

Inspiration

Online students rarely suffer from a lack of content. The harder problem is execution.

A student preparing for a test may already have lectures, playlists, notes, question banks and search results available, yet still lose valuable time deciding what to study next, which resource to trust, how much can realistically fit into the day, and what to do when the original plan slips.

That is the problem behind ACComplish.

We did not want to build another AI tutor that simply generates explanations on demand. We wanted to build an execution layer around online study.

A student might have completed one topic, be weak in another, not have started a third, have a test in seven days and only 90 minutes available each day. At that point, the useful question is not “What can AI teach me?” but “Given where I am right now, what should I actually do next?”

ACComplish turns that situation into a focused Study Line, deliberately limits the number of online resources the student has to choose from, records what actually gets completed, and adapts the remaining plan when reality differs from the original schedule.

That became our core loop:

PLAN → EXECUTE → REPORT → ADAPT.

And the product promise behind the tagline became simple: Study online. Stay on line.

What it does

ACComplish is an AI study-execution copilot designed to reduce the decision overload that often comes with studying online.

The student begins by providing the context that actually affects a study plan: academic or exam context, subject, exact topics in scope, readiness for each topic, target date, daily study capacity and any additional constraints.

ACComplish converts that context into a bounded, short-horizon Study Line with concrete day-wise tasks, priorities and realistic time estimates.

The student is then given a deliberately small Resource Lane rather than a search-results dump. Resources are organized into three roles:

Primary — the best available starting point Backup — an alternate explanation or reference Practice — material for applying and checking understanding

Execution is part of the product, not an afterthought. Every task can be marked Done, Partial or Skipped.

When unfinished work remains, the student can explicitly choose Adapt my Study Line. ACComplish uses that execution evidence to generate a revised plan while preserving completed effort, respecting the remaining deadline and staying within the student's daily capacity.

The result is a continuous loop:

PLAN → EXECUTE → REPORT → ADAPT.

ACComplish does not block websites or monitor browser activity. “Stay on line” means reducing study drift by narrowing what the student needs to decide next and where they need to look next.

How we built it

ACComplish is a full-stack web application built around a clear separation between student context, AI planning, online resource discovery, execution tracking and adaptive recovery.

The frontend uses React, TypeScript and Vite, with Tailwind CSS tooling and a custom responsive design system. The backend uses Python, FastAPI and Pydantic.

AI planning runs through Groq using openai/gpt-oss-20b and openai/gpt-oss-120b.

For both the initial Study Line and Adaptive Recovery, ACComplish uses a bounded AI-first pipeline:

  1. GPT-OSS 20B attempts structured generation.
  2. The result is validated locally against product invariants such as topic scope, dates, daily capacity, task IDs and plan coherence.
  3. If the output is unusable, GPT-OSS 120B receives one fresh structured attempt.
  4. If both AI attempts fail, a deterministic emergency planner or recovery path provides a validated degraded-mode result.

Those deterministic paths are reliability mechanisms, not AI generation.

Tavily powers online resource discovery. Search results are ranked and constrained into the Primary, Backup and Practice Resource Lane rather than being exposed as an unrestricted list.

The browser talks to the FastAPI backend through a same-origin API path. The frontend is deployed on Vercel and the backend on Render, with provider credentials kept server-side.

This architecture let us use AI for the parts where reasoning and adaptation matter while using conventional code to enforce the boundaries that make the output executable.

Challenges we ran into

One of the hardest challenges was realizing that generating more output was often the opposite of what the product needed.

It is easy for an LLM to create a long study plan, and it is easy for search to return many relevant-looking links. But both can recreate the same overload ACComplish is trying to solve. We had to make daily capacity a real ceiling, keep planning within the student's supplied topic scope, and deliberately constrain Resource Lane results.

AI reliability was another major challenge.

Structured provider output can still be unusable at the application level. During development, some model responses were technically valid but were rejected by local rules that were too focused on wording rather than genuine product constraints. We refined that boundary so AI retains freedom over pedagogical planning and concise wording, while code continues to enforce important invariants such as scope, dates, capacity, unique tasks and completed-work exclusion.

Adaptive Recovery was harder than initial planning because it has to reason from what actually happened. Done work must remain completed, Partial and Skipped work must be handled sensibly, the remaining deadline must still hold, and the new plan cannot silently exceed the student's available time.

We also had to resist scope expansion during the hackathon. Instead of adding tutoring, flashcards, social features, browser blocking or a large syllabus system, we concentrated on making the core execution loop genuinely work end to end.

Accomplishments that we're proud of

The accomplishment we are most proud of is that ACComplish does not end at “Generate plan.”

The complete product loop works:

student context → AI Study Line → curated Resource Lane → execution reporting → AI Adaptive Recovery → refreshed Resource Lane.

Progress therefore affects product behavior instead of existing as a decorative checklist.

We are also proud of the way the AI layer was made reliable without pretending that model output is automatically correct. Initial planning and Adaptive Recovery each have bounded 20B → 120B AI paths, followed only when necessary by deterministic emergency degradation. Generated output is checked against real product constraints before it becomes an actionable Study Line.

Another important accomplishment is restraint.

Resource Lane intentionally favors a small Primary / Backup / Practice set instead of maximizing the number of links. Daily capacity is treated as a ceiling rather than something the application must fill. The student supplies the study scope rather than letting the system casually expand into neighboring topics.

Most importantly, the live production flow was verified end to end: Study Line generation, resource discovery, Done progress, explicit adaptation and the refreshed Resource Lane all operate as one coherent system.

ACComplish became more than an AI-generated schedule. It became a small execution system built around the reality that plans change once students actually start working.

What we learned

The biggest lesson was that integrating an LLM is only one part of building an AI product.

The model can provide reasoning, prioritization and adaptation, but the usefulness of the final experience depends just as much on the surrounding system: what context is collected, how output is structured, which constraints are enforced in code, how external information is retrieved, how much information the interface exposes and what happens when an AI response is unusable.

We also learned that validation has to protect product invariants rather than over-control model wording.

A useful AI planning system needs enough freedom to generate natural subskills and concise actions, while conventional code should enforce the things that must not break: the student's supplied scope, target dates, daily capacity, unique task identity and completed work.

Another lesson was that more choice can reduce usefulness.

Resource discovery became more valuable when we stopped thinking like a search engine and started thinking like an execution product. A student usually does not need twenty potentially useful links. They need a good place to start, an alternative if necessary and something with which to practice.

Finally, Adaptive Recovery reinforced an important product insight: a study plan is only an initial hypothesis. Once execution begins, real progress becomes better information than the assumptions that produced the original schedule.

That is why REPORT → ADAPT became just as important to ACComplish as PLAN.

What's next for ACComplish

The next phase of ACComplish is about deepening the execution loop rather than expanding into unrelated education features.

The first major step would be persistence: student accounts, saved Study Lines, study history and continuity across devices and sessions. That would allow Adaptive Recovery to learn from a longer execution history instead of only the current planning cycle.

We also want to strengthen Resource Lane ranking and personalization so that resource selection can reflect not only the current topic, but also the student's previous resource choices, readiness and execution patterns.

Longer-term additions could include progress analytics, clearer recovery insights, broader academic and exam contexts and support for longer study horizons while preserving the short-term execution focus.

There is also room to make the “Stay on line” concept stronger through optional focus-oriented tools, but the core product direction will remain deliberately narrow.

The internet already gives students enormous amounts of study material. ACComplish should not compete by giving them even more.

Its job is to help them decide what matters now, work through a manageable line of action, report what actually happened and recover intelligently when the plan changes.

Built With

Share this project:

Updates

Submission history