Tako Studio — The Evidence-to-App Canvas

Build interactive learning apps from evidence. Tako makes the chain from learning science to UI, student use, and evidence-guided evolution visible in one canvas, and evolve them as learners use them.

Comment

Inspiration

I have spent nearly ten years as a software engineer, and I hold a doctorate in education from Johns Hopkins University, where my research examined how an AI-supported intervention could improve students' perceived instructional effectiveness. I approach educational technology from three perspectives at once: software engineer, education researcher, and product builder.

I began vibe coding with generative AI in 2023 and have witnessed the tools, coding agents, and models evolve firsthand—each generation letting me build faster, more accurately, and with greater complexity. Over three years I built more than twenty applications across learning, writing, language, visualization, and research. Some became open-source projects; others reached educators and researchers through social media and received strong public response. I also host a leading Chinese-language podcast on AI and education and became the top podcaster in this niche, and in early 2024 I received research support from OpenAI to continue this exploration.

I did not build all of those applications because vibe coding was exciting. Each one tested the same possibility:

Can learning science become executable—not merely knowledge an AI can explain, but knowledge an interactive application can embody, contextualize, and act upon?

This is, at heart, an alignment problem—the unification of knowing and doing. A model may hold declarative knowledge about learning science and procedural knowledge about software. It can explain a pedagogical theory and build an impressive application. Neither guarantees that the application truly enacts the theory, preserves its conditions, or collects the evidence needed to judge whether the design works. Once we give AI the ability to create tools that interact with people, the stakes rise: does the generated tool stay aligned with the educational purpose it claims to embody—from the first design decision through real student use?

Education is where this question matters most to me, because it is my field and because education is both an art and a science. The science offers theories, mechanisms, and evidence; the art lies in judgment, relationships, and presence. Technology should make the science easier to execute without crowding out the human work only educators can do.

Across those twenty-plus builds, my answer hardened into a design thesis: pedagogy should function as an architectural constraint, not a post-hoc wrapper. But the method for achieving it still lived in my head—research knowledge, engineering experience, and product taste combined manually, prompt by prompt. I could do it; I could not yet externalize, inspect, test, or delegate it.

Before Build Week, the idea existed as a static, hard-coded HTML prototype: an evidence-aware design canvas whose every relationship I had authored by hand. I used the hackathon to push one step further—turn my method into a pedagogical agent that could enrich knowledge, transfer it into design, generate an application, and preserve the logic connecting those stages.

That attempt exposed a second alignment problem: even a capable pedagogical agent is still a black box if people only see its output. Teachers, researchers, and product managers need to inspect how evidence becomes an application, participate in the design, and understand what changes when a decision is revised.

Tako Studio is my answer: a visual evidence and alignment layer for educational vibe coding.

By collapsing the time, cost, and technical knowledge required to build a personal educational tool—without treating teaching effectiveness as optional—Tako lets educators and researchers stop being consumers of standardized EdTech and become creators of tools grounded in their own students, evidence, and judgment. The point is not to automate educators out of education; it is to make the science cheap to construct and validate, so human attention can return to the art: relationships, presence, contextual decisions. That is the human–AI collaboration paradigm Tako explores.

What it does

Tako Studio is an agentic canvas for building pedagogically grounded interactive applications. Evidence, learning-science ideas, design decisions, UI/UX, a runnable student experience, and student-use data all live in one visual workspace.

A user begins with a learning goal, research evidence, or a problem. Tako does not jump straight to generated code. It builds a visible chain:

Evidence → learning principle → pedagogical decision → interaction → generated UI → student observation → next design decision

The canvas makes that chain spatial and interactive: a mind map of evidence and concepts, the logic connecting them, and a preview of the resulting interface beside the reasoning that produced it. Users can ask, “Why is this question here?”, “Which evidence supports this interaction?”, “If I change this decision, what else should change?”

The current prototype demonstrates one bounded learning flow: students predict, inspect two cases, compare what changed, and decide whether to revise their thinking. Teachers design that flow visually, step into the student Preview without leaving the workspace, and publish a real interactive application for learners to use.

Publishing is not the end. When Tako builds the application, the backend also generates logging for the intended learning interactions: which path a student took, where they changed an answer, where they stopped, what explanation they submitted. That usage data flows back into the exact same canvas where the application was designed, so the evidence map, pedagogical hypothesis, UI decision, and student observation can be examined together—rather than scattered across papers, product documents, codebases, and dashboards. Tako helps the teacher analyze what happened and surface possible revisions.

This creates two connected loops:

  1. The open design loop: evidence and educational intent become a visible design, then a runnable application.
  2. The closed evolution loop: student use becomes structured observation, returns to the original design logic, and informs the next version.

This is what “the app gets smarter as more people use it” means here. The system does not silently self-optimize or claim that clicks prove learning; it builds a progressively richer evidence environment in which the human makes better-grounded decisions about how the application should evolve.

And Tako is not only for teachers. A researcher can operationalize a theoretical construct; an EdTech PM can connect requirements to learning mechanisms and observable behavior; a learning designer can compare alternative flows before implementation. All of them work on the same underlying object: a traceable pedagogical decision system that can become software.

How I built it

I began with the visual prototype and a mental model, not a backend specification. My instructions to Codex carried the product intention, the knowledge-transfer logic, the relationships that had to stay visible, and the principles that could not be violated. Implementation details like database structure I deliberately left open, so Codex could infer the architecture required to produce the intended semantic outcome.

My role stayed at the level of meaning and alignment: Does the application express the intended reasoning? Does the evidence stay connected to the interface? Codex handled the induction from those principles into data relationships, architecture, logging structures, and cross-references. Together we established one shared project model connecting the canvas, UI preview, published application, and student observations. GPT-5.6 handles the language-rich work—reading evidence, distinguishing support from assumption, proposing design semantics—while deterministic checks protect the relationships that must not drift.

To keep myself honest, I created a dedicated evaluation sub-agent to inspect both behavior and visual quality. The loop became: generate, inspect, review from multiple expert perspectives, repair, test, verify in the browser. The prototype now includes 46 focused tests covering the places where the intended logic could be distorted or trust could break.

The stack—Next.js, React, TypeScript, the OpenAI Responses API, Structured Outputs, and a database for projects, versions, and student activity—supports the system but is not its contribution. The contribution is the visible, executable relationship among evidence, design, experience, and evolution.

How I used Codex

The core idea formed Sunday night; active development began Monday morning; a working, tested prototype existed in under twenty-four hours. For the first time in years of vibe coding, I did not need an all-nighter.

My earlier workflows required constant proximity to the model—monitoring every step, repairing drift. With Codex, I could state the goal, principles, and boundaries first, then let the agent work as an expert executor and return only when a decision genuinely required my judgment.

As a solo builder, the sub-agents were the expert review team I never had. Describing the expert I needed—learning-science reviewer, product critic, data-contract reviewer, UI/UX reviewer, evaluation specialist—was enough for Codex to create the role, and I could edit its responsibilities directly. Separate threads handled implementation, second-pass critique, repair, and verification, forming a closed development loop that GPT-5.6 reasoned across while preserving the stated principles.

Because I hold expertise in both software and education, I could recognize drift and intervene at the right level. The code did not need micromanaging; alignment needed supervising—and that was my job. The biggest gain was not speed but certainty: I could see which expert reviewed a decision, why it was made, what it affected, and whether it was tested. That is exactly the experience Tako gives its users.

The process I used to build Tako became its thesis: expertise can be delegated and orchestrated without surrendering human agency.

How I used GPT-5.6

GPT-5.6 is both part of Tako and the reasoning engine behind its development.

Inside the product, it performs the detect-and-induct work I used to do manually: reading a brief or body of evidence, identifying concepts and relationships, distinguishing support from assumption, and proposing how ideas become learner-facing interactions—then reasoning across the evidence map, design decisions, and generated experience. Its proposals stay visible so the human can inspect, edit, or reject them.

During development, it reasoned across the whole product rather than optimizing isolated files: translating principles into connected system behavior, tracing the consequences of changes across canvas and student experience, powering the expert critiques, and repeatedly closing the review-and-repair loop.

In this workflow, GPT-5.6 functioned as a collaborator capable of implementation and induction—not as autocomplete. I remained responsible for problem framing, domain knowledge, product taste, evaluation criteria, and the final authority over whether the result still meant what I intended.

Challenges I ran into

The first was deciding how much of the AI's reasoning to reveal. Tako's current users need some comfort with evidence, design, or technology; but as AI literacy rises, people will increasingly want to deconstruct the black box rather than receive a finished answer. The design challenge is making complexity inspectable without making it overwhelming. This is also a question of agency: drawing on self-determination theory, the interface is built to increase the user's sense of autonomy, competence, and control. The canvas is not decoration—it is how the user understands and directs the AI.

The second was evaluation. Honestly, I never experienced being led astray by the AI—my dual expertise let me recognize drift and redirect it. A scalable product cannot assume every user has that combination, so the evaluation agent must become stronger, more independent, and more transparent about what it can and cannot verify.

The third was preserving meaning across the full cycle: a research claim, a pedagogical principle, an interface decision, a student action, and a later interpretation cannot quietly become different things as they move through the system. Relatedly, student activity must never retroactively “prove” the learning science; Tako has to help users distinguish observation, hypothesis, and evidence while still letting feedback guide responsible evolution.

Accomplishments that I am proud of

  • One visual workspace holds the evidence map, pedagogical logic, design decisions, and runnable UI/UX preview.
  • A user can follow one idea from source evidence to learning principle, interaction, interface, and student observation.
  • Teachers, researchers, and PMs inspect and edit the same underlying decision chain from their own perspectives.
  • Student-use data returns to the design that produced it, creating a responsible path for versioned evolution.
  • AI proposals can be questioned or rejected without destroying the last valid version, and published versions stay stable so later observations still refer to the experience students actually used.
  • The interface states clearly that activity data is neither a grade nor proof of learning, and 46 focused tests guard the most important trust boundaries.

What I learned

Vibe coding is rapidly solving generation. It is not automatically solving grounded decision-making or alignment.

A pedagogical agent alone is not enough. If its reasoning stays hidden, the user receives another black box. Visualization is therefore not a presentation layer added after the intelligence—it is part of the intelligence: a shared surface where human and AI inspect the same evidence, decisions, consequences, and uncertainties.

The durable value is not the prompt or the generated code. It is the structured chain connecting knowledge, evidence, design, interaction, observation, and revision. Once that chain exists, many applications can be generated from it, evaluated against it, and improved without losing their intent.

Expert delegation can increase human agency rather than reduce it. Codex handled details I did not need to prescribe; I kept control over meaning, direction, and standards.

This points to a broader paradigm for AI in education. The future may not be one platform shipping the same tutor to everyone. A platform can understand a particular learner, teacher, and task; bring pedagogical and technical knowledge to that context; and co-design the most appropriate learning flow with the human. Personalized EdTech may ultimately mean personalized product generation—not just personalized content inside a fixed product.

What's next

Evaluation at scale.

I am already experimenting with AI-simulated students that exercise newly generated products through computer use—an early stress test before classroom use, never a replacement for real learners. In parallel, I am deconstructing existing EdTech products and research papers into reusable evidence, mechanisms, interaction patterns, and evaluation criteria that can be recombined into new learning workflows, generated as applications, and tested systematically. That is the path to producing pedagogically grounded EdTech at scale.

Tako is the visual, human-facing layer of that system. Alongside it, I am building a CLI-native educational framework for coding agents such as Codex and Claude Code: framework first, application second. Knowledge enrichment, transfer, generation, evaluation, and orchestration live in the framework, while task-specific UI/UX is spawned on the fly when a learner, teacher, researcher, or product team needs it. The Tako canvas gives people a way to participate visually in a process that would otherwise stay hidden inside a CLI agent.

Near-term work includes more bounded learning patterns, a richer evidence library, stronger evaluation agents, version comparison, and real testing with teachers and learning designers. I would be happy to discuss any of this with interested members of the OpenAI education, Codex, or research teams.

Tako Studio is not simply a way to generate a teaching app. It is a way to see how knowledge becomes an app—and to use new evidence to decide what that app should become next.

4. Built With

Add only the tags that are accurate for the submitted repository:

  • GPT-5.6
  • Codex
  • OpenAI Responses API
  • Structured Outputs
  • Next.js
  • React
  • TypeScript
  • Zod
  • PostgreSQL
  • Node.js
  • Vercel

Do not foreground PostgreSQL or other infrastructure in the project story. It is an implementation choice, not the reason Tako matters.

Built With

Share this project:

Updates