• 

  Self-adapting AI model for the future of the education

Inspiration

I started BiteCode at the end of 2024 to solve a problem I experienced myself.

As a developer, I wanted to keep learning, strengthen my fundamentals, and stay current, but long courses rarely fit into a normal working week. The problem was not access to content. It was turning learning into a consistent habit and lasting knowledge.

My original idea was simple:

Build a program that could teach me programming.

That idea evolved into BiteCode: a microlearning platform combining short personalized lessons, executable code, email delivery, and AI-assisted learning.

As AI models improved, the vision expanded:

What if the system could understand the learner, remember previous interactions, and adapt what happens next?

What it does

A Self-Adapting AI Mentor

For this hackathon, I focused on building an adaptive feedback loop around the existing BiteCode platform.

The goal was not to create another chatbot. It was to create an AI mentor that learns from each session and uses those signals to improve the learner’s next experience.

The system connects:

• Personalized microlearning lessons
• Natural voice conversations
• Conversation analysis
• Learner memory and progress signals
• Adaptive lesson generation
• Personalized email follow-ups

The result is a continuous loop:

Learn → discuss → analyze → reflect → adapt → learn again

How the experience works

1. Course calibration

The experience begins with a course-calibration conversation. The agent asks about the learner’s long-term goals, current experience, preferred learning style, and what they want the course to help them achieve.

This gives the system a clear direction from the start: not only what to teach, but why it matters to this learner.

2. A focused lesson

The learner receives a short lesson based on their goals, experience, and previous progress. Programming lessons can include executable code that can be run and modified immediately.

At the beginning of each session, the agent briefly connects the lesson to the learner’s longer-term objective and reinforces that completing this small step moves them closer to it.

3. A contextual voice conversation

After the lesson, the learner talks to an AI mentor that already knows the lesson topic, learning goal, and relevant learner context.

The mentor can calibrate the learner’s knowledge, ask retrieval questions, explain concepts differently, provide hints, challenge weak assumptions, and adjust the difficulty.

Its communication framework is inspired by Chris Voss’s Tactical Empathy. The purpose is not negotiation, but helping the learner feel understood and psychologically safe. The mentor acknowledges frustration or uncertainty, reflects what it hears, asks focused follow-up questions, and only then moves toward guidance.

This creates a more human flow:

Understand first → clarify → guide

4. Structured learning signals

When the session ends, a webhook sends the transcript, summary, questions, answers, and metadata back to BiteCode.

The backend converts the conversation into structured signals such as:

• What the learner understood
• What remains uncertain
• Repeated mistakes or blockers
• Whether the difficulty was appropriate
• What should be reviewed or learned next

These signals are treated as evolving evidence, not permanent labels.

5. Personalized follow-up and adaptation

The learner receives a concise follow-up with strengths, gaps, recommended next steps, and a small retrieval challenge.

The same information is then used to influence the next lesson. A strong result can increase the difficulty, while uncertainty can trigger another explanation, targeted practice, or spaced repetition.

The mentor therefore does not restart from zero in every session. It gradually builds continuity.

How I built it

The hackathon experiment focused on one question:

Can the result of a real mentoring conversation improve the learner’s next experience?

To test this, I connected the full workflow:

1. BiteCode passes lesson and learner context to the voice agent.
2. The voice platform sends session results through a validated webhook.
3. AI analysis converts the conversation into structured learning data.
4. The result is stored in the learner profile and relationship context.
5. BiteCode generates a personalized follow-up.
6. The next lesson or session uses the new signals.

Technical architecture

The prototype combines several specialized services:

• OpenAI models for reasoning, personalization, analysis, and content generation
• A voice-agent platform for spoken mentoring
• Cloudflare-based serverless services for APIs and orchestration
• Webhooks and queues for asynchronous processing
• A database for learner profiles, history, and adaptive signals
• A web lesson interface with executable coding environments
• Email delivery for lessons and follow-ups

This modular approach allowed one developer to build and connect a sophisticated learning workflow in four intensive days.

Challenges I ran into

Reliability around non-deterministic AI

Language models can produce different reasoning paths and wording from the same context. Natural variation is useful, but a production experience still needs predictable boundaries.

I added structured outputs, validation, bounded retries, explicit conversation states, conservative fallbacks, idempotent processing, and behavioral rules. The main lesson was that a reliable AI product is not only a strong prompt. It is deterministic control built around probabilistic intelligence.

Extracting useful learning signals

A transcript does not automatically reveal genuine understanding. The system must distinguish a correct answer from a guess, hesitation from confusion, and a one-time mistake from a recurring gap.

The prototype uses structured analysis and keeps conclusions tentative until repeated interactions provide stronger evidence.

Voice timing and distributed state

Voice introduces problems that text chat does not: speaking state, learner-answer timing, silence recovery, microphone state, interruptions, and race conditions.

At the same time, context must remain consistent across the frontend, voice agent, Workers, database, webhooks, analysis jobs, and email delivery.

Solving this required an explicit state machine, signed context, careful timer cleanup, staged recovery, and end-to-end testing of the deployed journey.

Scope and privacy

Vibe coding makes every new idea feel immediately buildable. I had to keep returning to the smallest useful proof: one conversation should meaningfully influence the next learning step.

Personalization also requires restraint. Learners should know what is stored, how it affects future lessons, and how they can inspect or remove their data.

Accomplishments that I'm proud of

Closing the adaptive loop

The biggest accomplishment is that BiteCode now connects the complete journey: lesson delivery, contextual conversation, analysis, learner memory, follow-up, and adaptation.

The value is not one isolated AI feature. It is the continuity between them.

Creating a more human mentoring style

I integrated Tactical Empathy principles into the conversation framework. The agent is instructed to understand before advising, gently label emotions, reflect the learner’s perspective, ask one focused question at a time, and avoid pretending to understand more than the available evidence supports.

This makes calibration and coaching sessions feel less like an automated questionnaire and more like a supportive conversation.

Moving from a demo toward a product

The work went far beyond prompts. I implemented signed session context, webhook validation, idempotent processing, database migrations, demo isolation, voice-state recovery, answer protection, and deployed end-to-end verification.

Alongside the adaptive model, I also added many smaller product features. The agent now has a complete controlled tool set that can:

• Display structured questions in the interface
• Show relevant code snippets
• Coordinate lesson interactions and state
• Trigger dedicated interface actions
• Support donation collection

These tools allow the agent to act through the product instead of only speaking, making the experience feel like a complete interactive learning system rather than a voice chatbot.

Building it as an individual developer

In four days, I worked across product design, AI behavior, voice interaction, frontend state, backend processing, databases, security, and deployment.

AI-assisted development did not remove the difficult decisions, but it made it possible to reach, implement, and test them much faster.

What I learned

The value is in the loop

The most important capability did not come from a single model. It emerged from connecting systems:

• The lesson creates context.
• The conversation creates interaction.
• The analysis creates learning signals.
• The database creates continuity.
• The follow-up creates reflection.
• The next lesson creates adaptation.

AI needs deterministic boundaries

The model can interpret, explain, and personalize. The application must enforce identity, permissions, schemas, state transitions, retries, validation, and timeouts.

Stable quality does not require identical responses. It requires useful variation inside reliable boundaries.

Vibe coding changes the bottleneck

AI dramatically reduces the time needed to create software. The bottleneck moves from typing code to choosing direction, controlling scope, testing assumptions, and deciding what is worth building.

Speed creates possibilities. Product judgment turns them into a coherent experience.

Human connection still matters

A good mentor does more than deliver information. A good mentor listens, remembers, challenges, encourages, adapts, and recognizes progress.

The future of education may depend less on generating more content and more on creating better learning relationships.

BiteCode is personal because I am building the mentor I wanted for myself: one that helps a learner continue even when time, confidence, or motivation is limited.

What's next for BiteCode

The prototype proves the adaptive loop, but the longer-term work includes:

• A richer, learner-visible Knowledge Map
• More reliable learning-signal extraction
• Recurring retrieval practice and knowledge checks
• Progress tracking across many sessions
• Learner control over stored memories and conclusions
• Connections between learning gaps and real development work
• Measurement of long-term retention and habit formation

The long-term ambition is to create a mentor that stays with the learner throughout their professional journey.

A mentor that does not merely answer questions.

A mentor that learns how to help.

Final vision

Advanced technology should not make learning more complicated. It should make powerful personal mentorship feel simple, natural, and accessible.

BiteCode is my attempt to make adaptive, lifelong learning available to anyone—regardless of where they live, how much uninterrupted time they have, or what device they can afford.

Built With

• api
• cloudflare
• elevenlabs
• typescript
• vscode