Building an AI-powered learning experience.

Meniva's own application: a full-stack learning platform with executable practice and an AI mentor inside the lesson. Live at learncontour.com.

◖ ListenText to speech · approx. 3 min

Null

Function versus method

A plain function receives all data as parameters:

def balance_after_charge(balance, total):
    return balance - total

A method does the same through self, on the own state of the instance:

class Invoice:
    def __init__(self, owner, balance):
        self.owner = owner
        self.balance = balance

    def charge(self, total):
        self.balance = self.balance - total

Null I am paying attention.

Method

What is this __str__ method, does it always exist with the class or we need to create it?

NullAI mentor

Where to look

Look again at the line def charge(self, total): and compare it with the plain function above. Focus on what self connects the method to when the object is used; apply that same comparison when you inspect def __str__(self):.

Was this helpful? 👍 👎

Role: Product, architecture, full-stack engineering, content pipeline, operations
Status: Live, invite-based access, English and Hungarian
Stack: React, FastAPI, MongoDB, Qdrant, sandboxed Python execution, Railway and Vercel
Curriculum: 16 authored tracks from Python foundations to LLMs, agents and ML systems operation

Overview

Contour is an adaptive learning system for data and AI careers, starting with the shared foundations: Python, working with data and the mathematics models need. It finds where the learner is, sets the next useful challenge and gives only as much help as needed. AI has made answers easy to get; Contour uses it so the thinking stays with the learner.

It is also Meniva's proof of end-to-end product engineering: the same team framed the product, designed the architecture, wrote the application, built the content pipeline and runs it in production.

Learning experience

First together, then alone.

A diagnostic sets the starting point, and every next task follows from what the learner has actually done. If an earlier foundation is missing, the path steps back to it first. Short explanations lead into code, prediction and project-linked tasks; shaky concepts return for review, and the scaffolding thins out until the learner works alone. Progress is recorded per concept as evidence in four dimensions (recognition, execution, explanation and transfer), not as a percentage.

G8: cubes of numbers divisible by three with a comprehension

Python · estimated time: 8 min

Step throughReset▶ Run tests

Explanation and task

Write the cubes_of_multiples_of_three(numbers) function with a list comprehension: it should return the cubes of the elements divisible by three, in the original order.

1def cubes_of_multiples_of_three(numbers):
2    return [n ** 3 for n in numbers if n % 3 == 0]

TestsConsole2/2 tests passed

✓ A mixed input of elements divisible and not divisible by three

input cubes_of_multiples_of_three([1, 2, 3, 4, 5, 6])

expected [27, 216]

actual [27, 216]

✓ An empty input

input cubes_of_multiples_of_three([])

expected []

actual []

Executable practice. The learner's code runs against test cases in a sandboxed service; the tests, not the syntax, decide whether the step is done.

The progress map. Each concept shows the evidence collected so far and the next useful step; a concept without evidence is unexplored territory, not a failure.

AI functionality

A mentor that reads the task, not a chat box.

The mentor, named Null, sits at the edge of the workspace. It sees the current task, the learner's own code and where they are on the path, so nothing has to be explained twice. It starts with the smallest help that fits, often a question or a pointer to where to look, and each further request goes exactly one step further. If a foundation is missing, it steps back to it instead. It never hands over the finished solution: the learner writes it.

A support ladder: a question, a pointer, the next step, then smaller steps
Starting rung chosen from what the learner's work so far shows
Retrieval over course reference material for explanations
Text and voice with the same grounding, within a daily allowance per account
Cost and latency budgets enforced per request

Null I am paying attention.

Task · Functions

Question
Pointer
Next step
Smaller steps

Write a function that returns the average of a list of numbers, and None for an empty list.

I can't see what goes wrong with an empty list

01 · Asks

Which inputs does the task mention, and what should your function return for each?

02 · Points

Look again at the last line of your function.

03 · Names the next step

The error comes from the division. You need a decision before you divide.

04 · Breaks the task into steps

1. How can your code tell that the list is empty? 2. What should the function return in that case? 3. What has to be true before the division runs?

Each further request adds one step, never the solution.

The support ladder in the mentor panel: each further request goes one step further, never to the solution.

Architecture

Built to be operated by a small team.

Application: React front end on Vercel; FastAPI services on Railway; MongoDB for curriculum, progress events and accounts; authentication, billing and bilingual content built in.
Code execution: Learner code runs in an isolated executor fleet with a scheduler, resource guards and an execution ledger, so practice is real and the platform stays safe.
Retrieval and mentor: Reference material chunked and indexed in Qdrant; the mentor composes learner state, task context and retrieved passages, with per-request cost controls and a voice path.
Content pipeline: Lessons authored as structured source, validated, localised and imported by script; visual explanations rendered programmatically. Sixteen tracks maintained this way.
Instrumentation: Attempts, hints and completions are recorded as events; learning analytics are derived from them and feed what gets built next.
Release discipline: Automated API and end-to-end tests, performance budgets and release qualification scripts gate every deploy.

Where the claim stops

Contour is live and in use under invite. No learning-impact or user-growth figures are claimed; outcomes have not been validated at cohort scale.

Next project

Miutcánk →

Need a product built, not just a model integrated?

Discuss your project info@meniva.net