Structured Learning: An AI-powered platform that transforms academic papers into interactive learning experiences.
FORMAT: TalkLEVEL: IntermediateLANGUAGE: Spanish
Structured Learning: The AI Platform That Other AI Agents Build" Subtitle: A real platform that converts academic papers into interactive learning modules, built as a solo developer with an agent pipeline that takes every GitHub issue to a merged PR, on pure Python, async FastAPI, and AWS
What do you do when you need to understand and implement a research paper, and existing tools force you to jump between five tabs — PDF viewer, ChatGPT, IDE, notes, a search engine — and every jump breaks context? And what happens when, on the other side of the problem, you're a solo developer trying to build something serious to solve it, with AI agents that usually work well in demos but fall apart in production?
This talk is the engineering story of Structured Learning: a platform that converts a research paper into a complete learning module — chapter-by-chapter explanations, incremental executable code, RAG chat, FSRS spaced-repetition flashcards, equation derivations, and a Neo4j knowledge graph connecting concepts across the user's entire library. Nineteen of forty-two features delivered as a solo developer. The product is the visible half. The interesting half is how it was built.
The first topic is the product. Where a static tool promises "upload the PDF, get a summary," Structured Learning accompanies the three phases of working with a paper — researching it, understanding it, and applying it — across four custom AI agents in async FastAPI and LiteLLM, with multi-provider support across Anthropic, OpenAI, Google, DeepSeek, and Ollama.
The second topic is engineering: an agentic development workflow pipeline that takes a GitHub issue to a merged PR — planning, implementation, tests, review, automatic patching, conflict resolution, documentation, and release. Each phase runs in an isolated git worktree with its own port range, so agents actually run in parallel without checkout contention. Commands in GitHub comments (/plan, /patch, /conflict) trigger background workflows that post phase-by-phase progress back to the same issue, creating a human-readable audit trail. Adaptive routing sends trivial classification to fast, cheap models, and heavy review or debugging to stronger models. PR creation is deferred until all quality gates are green — unit tests, end-to-end tests, and review. When review finds blockers, the pipeline automatically launches a patch workflow to fix them in place and re-runs verification. Real self-repair, no human in the loop for the common "almost right" case.
The third topic is production: how this runs on AWS without breaking, and how we develop it locally without paying for cloud. The entire stack — S3 for PDF uploads and TTS audio cache, ECS Fargate for FastAPI backend and GROBID service, RDS PostgreSQL 16 with pgvector extension consolidating application DB and vectors, Secrets Manager for credentials, ECR with immutable image promotion — lives on Terraform with per-environment directory separation. The key to maintaining dev↔prod parity is LocalStack plus a single variable (S3_ENDPOINT_URL): the same boto3 client runs identically on both sides, no code branches, no mocks in tests. docker compose up reproduces the full AWS topology locally, enabling end-to-end flows — paper upload, audio generation, caching — without real credentials or cloud costs during development.
You'll leave with a clear view of the product — a platform that covers the three phases of working with an academic paper. For research, it offers conversational search over arXiv and OpenAlex, and a Neo4j graph that detects shared concepts, knowledge gaps, and optimal reading order across your entire library. For explanation, it generates chapter breakdowns with key concepts and diagrams, step-by-step equation derivations that demystify the math, RAG chat and Socratic mode that answers with the paper's full context, and an annotatable PDF reader with "Ask AI" on any selection. And for practical application, it produces executable code that builds incrementally with dependency tracking, FSRS flashcards for measurable long-term retention, and comprehension quizzes that validate understanding chapter by chapter. And with three concrete engineering recipes to reproduce in your own stack. One for building serious AI products without magic frameworks: typed contracts with Pydantic, SSE streaming with cancellation, prompt caching, and per-task cost accounting. Another for scaling a solo developer to team velocity by applying agentic discipline to your own development cycle: isolated worktrees, resumable pipelines, auto-patching after failed review, GitHub as the agents' API. And a third for eliminating "works on my machine" from AWS infrastructure using LocalStack as a local S3 mirror. The thesis: agents don't replace engineers, they replace the glue between engineers and the boring 80% of the SDLC — and that's where compound returns live.
