adicheo

Study Guide App Concept

8 min read

Love this — huge, beautiful idea. I can feel the scaffolding already. Below I laid out a practical, high-level product blueprint you can act on right away: vision → core features → data model → UX flows → algorithms → tech choices → MVP roadmap → privacy & quality controls → metrics. I also included small, copy-pasteable JSON schema examples and a short pseudocode algorithm for generating personalized mastery plans. Pick whatever you want me to expand into a prototype (wireframes, API spec, React component, or DB schema) and I’ll build it next.

Vision (one sentence)

A living, versioned study-encyclopedia that teaches you to master purpose-directed goals by combining dynamic content, argument maps, active assessment, spaced practice, and transparent evidence provenance.

Core principles

  • Purpose-first: every study path starts from a user goal and maps to concrete subskills.

  • Transparent evidence: every claim links to sources; distinctions made between fact, theory, argument, statistic, opinion and fallacy.

  • Versioned definitions: definitions and concepts evolve with time and are versioned with provenance.

  • Active learning loop: learn → test → reflect → expand.

  • Networked view: visual, explorable graph of claims / arguments / resources.

Key features (priority order)

  1. Goal & Mastery Planner — user defines a high-level goal (e.g., “Master introductory microeconomics in 6 months”), system breaks into skills/learning objectives and measurable outcomes.

  2. Topics / Claim Graph — nodes = concepts/claims/theories; edges = supports/contradicts/refines/uses; each node shows provenance, versions, meta (confidence, tags).

  3. Study Paths — linear/adaptive plans derived from the graph and user goal; each step has objectives, resources, exercises.

  4. Source Manager — ingest text, PDF, video, dataset; extract claims, quotes, timestamps; store metadata + canonical citation.

  5. Assessment Engine — multiple question types (MCQ, short answer, proof/calc, logic puzzles, essay prompts + rubric), auto + human adjudication.

  6. Adaptive Spaced Practice — scheduling using SM-2 or IRT; supports micro-practice (flashcards), worked problems, synthesis tasks.

  7. Argument Sandbox — structured debate tool where users or models map arguments, counterarguments, fallacies, and rate persuasiveness & evidence.

  8. Evolution Timeline — view how definitions/theories changed over time with citations and author annotations.

  9. Skill Diagnostics — fine-grained mastery scores (knowledge, reasoning, rhetoric, memory).

  10. Collaboration & Peer Review — crowdsourced edits, moderated voting, expert claims.

  11. Export & Reference Tools — citation bundles, study packs, printable notes, API for external tools.

  12. Ethics / Trust UI — clear indicator of content type (opinion/theory/empirical), credibility score, conflicts of interest.

Data model (compact JSON examples)

Use these as starting schema for Postgres + JSONB and a vector DB for embeddings.

Topic / Claim node:

{
  "id":"claim:uuid",
  "type":"claim",            // claim | concept | definition | theory | fallacy
  "title":"Efficient Market Hypothesis (weak form)",
  "body":"Prices reflect all past market information...",
  "tags":["finance","economics"],
  "confidence_score":0.42,
  "provenance":[
    {"source_id":"src:doi:10.1000/xyz", "quote":"...","position":{"page":12}}
  ],
  "versions":[
    {"v":1,"author":"Fama 1970","date":"1970-01-01","notes":"original formulation"}
  ],
  "embeddings":[/*vector*/],
  "created_at":"2025-09-21T10:00:00Z"
}

Resource:

{
  "id":"src:uuid",
  "kind":"pdf|article|video|dataset",
  "title":"Journal of Finance — Random Walks",
  "authors":["Eugene F. Fama"],
  "url":"https://...",
  "metadata":{"doi":"10.1000/xyz","length_s":3600},
  "ingest_state":"parsed|pending",
  "text_index":"... (fulltext or summary)",
  "created_at":"..."
}

User Progress / Plan:

{
  "user_id":"user:uuid",
  "goal":"Pass microeconomics final",
  "plan":[
    {"step_id":"s1","topic_id":"topic:uuid","due":"2025-10-15","status":"todo","mastery":0.2}
  ],
  "mastery_profile":{"logic":0.35,"memory":0.6,"problem_solving":0.2}
}

UX / Dashboard ideas

  • Landing dashboard: Goal cards, mastery progress, suggested next activity, daily micro-practice.

  • Graph explorer: central claim node, surrounding supports/contradicts nodes; hover shows quick-card with provenance; click opens deep pane.

  • Study pane: left — step objectives; center — resource & reader with highlights; right — exercises & spaced practice widget.

  • Timeline/Version viewer: slider to scrub through historical versions of a definition.

  • Debate editor: drag a node to add counterargument, attach evidence, tag fallacy types.

Algorithms & learning logic

  1. Plan generator (high level)

    • Decompose goal via curriculum templates + graph traversal:

      • find n root topics relevant to goal via embeddings

      • expand prerequisites breadth-first to depth D

      • cluster skills into weekly milestones

  2. Mastery estimation

    • Combine evidence from: assessment results (weighted), practice retention (SM-2 decay), concept coverage (percentage of key claims understood), and difficulty calibration (item difficulty).

    • Use Bayesian updating per skill.

  3. Source credibility score

    • Factors: source type (peer reviewed, gov, blog), citation count, recency, author credibility, domain reputation, fact-checking flags, community votes.

    • Normalize to [0,1] and display bands (low/med/high).

  4. Argument ranking

    • Rank arguments by aggregated evidence weight × rhetorical score × novelty penalty.

  5. Spaced scheduling

    • Implement SM-2 initially; upgrade to IRT for item-level difficulty and user-latent ability later.

Content ingestion pipeline

  • Accept: PDFs, web URLs, YouTube, EPUB, plain text, datasets.

  • Steps:

    1. Extract text + metadata (PDF parser, yt-download + autom. transcript).

    2. Chunk + embed (sentence & paragraph level).

    3. Claim extraction: run extraction model to detect candidate claims, associated evidence spans, numbers & datasets.

    4. Human-in-the-loop verification: crowd editors or experts tag claims as ✅ / ❌ / needs review.

    5. Add to graph with provenance + version.

Quality control & governance

  • Editorial tiers: community edits → curator review → expert verification.

  • Attribution & provenance UI: every claim shows primary source and edit history.

  • Dispute mechanism: claims can be flagged, then placed into “disputed” state with visible counterarguments.

  • Moderation rules: block hate, illegal content; disallow fabricated evidence.

Privacy, legal & ethics

  • Store sensitive user data encrypted at rest; support export & deletion.

  • For copyrighted content, follow fair use: store excerpts + link back; allow users to upload only if they own/are permitted or provide public sources.

  • For medical/legal/political high-stakes content: show disclaimers and require higher evidence thresholds.

Tech stack (recommended, pragmatic)

  • Frontend: React + TypeScript + Tailwind (or shadcn/ui if you want component speed).

  • Backend: FastAPI (Python) or Node/Express; GraphQL for flexible queries.

  • DB: Postgres (primary relational) + pgvector for embeddings OR Postgres + Pinecone/Weaviate for vector store.

  • Search: Elasticsearch/Opensearch for full text.

  • Embeddings/LLMs: OpenAI embeddings (or open-source like Llama-2 embeddings alternative), LLMs for summarization/generation with human verification.

  • Task queue: Redis + Celery / RQ for ingestion pipelines.

  • Auth: OAuth and optional SSO, JWTs.

  • Hosted infra: Docker + Kubernetes for scale, use managed DB + vector DB for faster bootstrap.

  • Analytics / experimentation: PostHog or Mixpanel.

MVP (90-day plan, focused)

Week 0–2: Product definition, one-page curriculum templates (e.g., “Intro to X”), database schema.

Week 2–6: Minimum features:

  • Goal creation + simple plan generator (rule-based).

  • Topic/claim nodes + simple graph visualization (D3).

  • Resource ingestion from URLs & text only.

  • Basic assessment: multiple-choice + flashcard SM-2 scheduling.

    Week 6–10:

  • Claim extraction prototype (LLM-assisted) + provenance link UI.

  • User progress dashboard + mastery scoring.

    Week 10–12:

  • Peer editing flow, dispute flags, versioning for definitions.

  • Polish + alpha testing with a small cohort.

Example user flow (concise)

  1. User sets goal: “Master Bayesian reasoning to apply in data science projects in 4 months.”

  2. System generates study path: prerequisites (probability, conditional probability), weekly milestones, initial resources.

  3. User studies a lesson (video + annotated article). Highlights a paragraph → creates a flashcard automatically.

  4. System quizzes user (MCQ & short problem); updates mastery.

  5. A week later, spaced scheduler resurfaces items with adjusted intervals.

  6. User examines claim graph for “Bayes’ theorem”: sees supporting proofs, historical development, common fallacies; can add a counterexample or propose a new resource.

Metrics & success criteria

  • DAU/MAU for active studying.

  • Time spent in active practice per session.

  • Mastery progress velocity (avg. mastery gain per week).

  • Retention (30/60/90 day).

  • % of claims verified by experts.

  • User satisfaction w/ study plans (NPS for plans).

Small, practical operations to start 

right now

  • Create 3 curriculum templates: (1) quick skill (2-8 weeks), (2) university module (12-16 weeks), (3) deep-dive research (6+ months).

  • Build the DB schema for topics + claims + resources (I can generate SQL).

  • Prototype a single React page: Graph explorer + resource viewer + practice widget (I can create the React code).

  • Run a 1-week content sprint: ingest 10 high-quality resources for one domain (e.g., probability theory) and annotate claims.

Mini pseudocode: generate a personalized mastery plan

input: user_goal, user_profile, time_budget_weeks
1. seed_topics = semantic_search(goal_embedding, global_topic_index, top_k=10)
2. prerequisites = expand_prereqs(seed_topics, depth=2) // graph traversal
3. cluster into milestones by skill_family
4. for each milestone: choose resources weighted by (credibility*relevance*length_fit)
5. schedule milestone into calendar using user time_budget and SM2 for practice slots
6. output: ordered steps with objectives, resources, assessments

Risks & tricky parts (callouts)

  • Claim extraction is noisy; requires human QC.

  • Authority vs. openness: balancing community edits with trust.

  • Scalability of graph: need efficient graph DB / caching.

  • Assessment correctness for open problems / code requires human grading or sandboxed autograders.

If you want, I can:

  • generate the initial SQL schema and an API spec for Topics/Claims/Resources/Plans; or

  • produce a playable React prototype of the Graph Explorer + Study Pane (single file, Tailwind, previewable); or

  • craft 3 curriculum templates and a micro content ingestion checklist you can hand to contractors.

Tell me which of the three you want and I’ll produce it right away — or I can pick the API schema by default and start wiring the backend schema for you.

Backlinks

Graph View