Inspiration
You can finish a course, follow every tutorial, and still freeze when the file is blank.
Now AI can write the code too. That makes the problem more urgent: if AI does all the building while you are trying to learn, what are you becoming?
Tutorials made learners spectators. Coding agents can make them passengers. I started Tangeble because learning should make you more capable, not merely help you produce more output.
What Tangeble does
Tangeble does not hand every learner a frozen syllabus. It creates a living course around something they genuinely want to build, then changes that course with them.
Imagine telling Tangy, “I want to understand how systems scale.” Tangeble can turn that into a focused two-day project: build a tiny service, put it under load, find the bottleneck, and see what changes when you add caching. Learning does not have to mean building a huge full-stack application every day. A project can be a one-hour experiment, a small build for the next few days, a weekend tool, or a deeper portfolio project.
The learner can keep shaping the course in ordinary conversation:
- “Caching finally clicked. Add a deeper module on it.”
- “Show me this lesson visually.”
- “Make this explanation shorter, but give me a harder challenge.”
- “Add load balancing next.”
- “I want to contribute to open source. Teach me through this repository.”
Tangy can revise the existing course, add or rewrite lessons and modules, change the depth or direction, and steer what comes next. The learner does not have to abandon one rigid course and search for another every time curiosity moves.
The course outline and early lessons appear quickly while deeper project preparation continues in the background. Tangy teaches through predictions, attempts, debugging, and graduated hints instead of immediately taking the keyboard. Every learner also gets browser-based VS Code, so the work happens in a real coding environment rather than a toy exercise.
Tangeble keeps the learner journey—their goals, course changes, progress, attempts, interests, and completed work—so the next lesson and future projects can start with context instead of starting over. Finished work becomes a project record and resume-ready bullets, not just a certificate saying a video was watched.
Behind the learning experience, Tangeble prepares a working reference project and checks it before asking the learner to rely on it. If the system cannot verify the project, it says why instead of presenting broken AI output as success.
AI builds the world around the learner's goal. The learner becomes the builder inside it.
The Build Week story: we ran Codex like a company
I did not use Codex as autocomplete, and I did not ask one agent to generate Tangeble in one giant prompt. I organized persistent Codex agents into a small company with roles, decision rights, a Linear work queue, and independent verification.
I remained the founder and made the final product calls. I rejected work when it was technically impressive but wrong for the learner—including a landing-page direction that felt like disconnected feature cards and a reference-project plan limited to static HTML and CSS.
Sol became my standing Codex co-founder. Sol challenged scope, found the sharper learner problem, prepared decisions, wrote rigorous briefs, and directed work through Linear without turning into another code worker.
Terra acted as the engineering manager. It ran persistent implementation loops, kept issues moving, collected evidence, and escalated failures. Luna and other Codex executors worked on bounded tasks in parallel across the agent runtime, course pipeline, execution sandbox, authentication, web search, frontend, and demo. Separate Codex verifiers then ran the acceptance criteria again; the agent that wrote a change was never the only agent allowed to call it finished.
The loop looked like this:
Founder decision + Sol critique → Linear brief → Terra manager → Luna/Codex executors → independent verifier → receipts → accept, repair, or reject.
That organization is one of the biggest things we built during the week. Codex participated in strategy, project management, implementation, testing, adversarial review, visual direction, and the decision to refuse false success.
How GPT-5.6 powers Tangeble
Tangeble's product runtime is a specialized tutoring team built with the OpenAI Agents SDK and native Responses API. GPT-5.6-family models plan and reshape personalized courses, create and edit lessons, coordinate specialist roles, tutor the learner, search the current web with citations, and create the private reference project.
The roles have separate tools and boundaries instead of sharing one giant prompt. Tangy is learner-facing; planning, content, code, and validation work happen behind it.
The key design decision is simple: GPT-5.6 creates and adapts the learning environment, but generated output does not certify itself.
Challenges we ran into
Before the SDK port, our tutor ran inside each learner's sandbox and could build and test freely. After we moved the agent team onto Render, that execution ability disappeared. We almost papered over the gap with a static webpage generator, but that would not serve someone learning React, Python, Docker, open source, systems engineering, or anything beyond basic web pages.
We rebuilt the execution layer around disposable E2B sandboxes and independent verification. It took ten funded live rounds to harden. Nine attempts failed for specific, visible reasons; the tenth React task board was built, tested, and independently reproduced before the system called it ready.
We also had to keep the learner experience fast. Tangeble publishes from the front so a learner can begin the course while the deeper project work continues in the background.
What is working today
- A learner can describe a goal in chat and receive a personalized course.
- The same conversation can revise a course, add or rewrite lessons and modules, go deeper, or change direction.
- Course structure and early lessons appear while the reference project is still being prepared.
- Tangy teaches with graduated help and can perform cited live web search.
- Every learner gets an E2B workspace with browser VS Code.
- A real React task board was generated, built, tested, published, and checked again in a fresh sandbox before it was called ready.
- Deliberately broken projects were refused with a specific reason instead of being shown as successful.
- Learner-journey and project-evidence surfaces include resume-ready project bullets.
- The verified task-board run used approximately $0.02 of sandbox compute, excluding model and product-infrastructure costs.
What we learned
The learner—not the generated artifact—has to remain the hero.
We learned that personalization cannot end after the first prompt. A useful curriculum has to remain editable as curiosity, confidence, and goals change.
We also learned that speed and rigor can coexist. The learner can begin early while verification continues underneath.
What's next
Next we are adding safe practice folders that remove scaffolding as the learner becomes more independent, plus evidence-based skills that distinguish “seen it,” “did it with guidance,” “did it alone,” and “can build with it.”
We also want Tangeble to support open-source contribution courses: clone a real repository, reproduce its tests, understand its structure, and teach the learner through a contribution that matters.
AI can build almost anything. Tangeble is here to make sure learners still can.
Built With
- chatkit
- codex
- e2b
- fastapi
- github
- gpt-5.6
- next.js
- openai-agents-sdk
- openai-responses-api
- openai-web-search
- python
- react
- render
- supabase
- typescript
- vercel