convez.ai
SkillProdutividadeIntermediário
voidnologo

Primer — Sistema de Aprendizado Adaptativo

voidnologo/primer

Tutor adaptativo que aprende seu estilo e nível, acompanhando seu progresso

Ver no GitHub
InicialPluginScore · de 0 a 100

Uma skill Claude que funciona como tutor pessoal adaptativo para qualquer assunto, calibrando lições interativas ao perfil persistente do aprendiz. Inspira-se no conceito de 'Young Lady's Illustrated Primer' de Neal Stephenson, capturando cada sessão em artefatos markdown duráveis que crescem com o usuário.

Instalação

$npx convez-ai voidnologo/primer

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
1
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 1 mês
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Aprendizado autodirigido em qualquer disciplina mantendo progressão histórica
  • Acompanhamento de conhecimento em campos que evoluem rapidamente
  • Desenvolvimento de currículo personalizado sem palestras genéricas
  • Construção de base de conhecimento pessoal em markdown reutilizável

Veredito

Uma abordagem genuinamente diferente para aprendizado contínuo — menos 'chatbot de Q&A' e mais 'relacionamento educativo'. A inspiração literária traduz-se bem em prática: lições que se ajustam ao seu nível, histórico mantido em artefatos próprios, foco em 'puxar conhecimento' versus 'empurrar currículo'. Vale explorar para quem busca aprendizado estruturado mas genuinamente personalizado.

README

A tradução para o português deste README ainda está na fila.

primer

A personal, Primer-style learning system — an adaptive tutor for any subject, that runs interactive lessons calibrated to you and gets sharper the more you use it.

New here? Start at voidnologo.com/primer — what it is, what makes it different, and how to get set up. From there, launch the pitch deck — it walks through the motivation, what it is, and how it works. Add ?print-pdf to export a PDF. Source lives at docs/pitch/primer-pitch.html.

What's a "Primer"?

In Neal Stephenson's The Diamond Age, the Young Lady's Illustrated Primer is the book you wish you'd had as a kid. It starts with a grandfather who wants something more for his granddaughter — who sees the makings of someone remarkable in her and sets out to give her every chance to become it. So he commissions a marvel, a book made possible only by technology just dreamed into being: it talks back, notices who's reading it, and reshapes itself to fit them. A copy finds its way to Nell, a young girl it was never made for — and it works just as beautifully for her. That's the heart of it: a book like this could do this for anyone.

It meets her exactly where she is, and grows right along with her. It pays attention to what lights her up — the questions she keeps asking, the things she's already quick at — and teaches through a fairy tale she can step straight into: Princess Nell, adventuring through a world of puzzles, locked doors, and clever escapes. Reading first, then logic, then honest-to-goodness computation (a Turing machine smuggled in as an enchanted castle), then how to hold her own, and finally the best part of all — how to think for herself. Never a lecture. Never pitched over her head or beneath it. Always just a step past what she can already do, so there's always something exciting to reach for.

Year by year, the Primer helps an ordinary kid grow into one of the most capable, quick-witted people in her world. The magic was never really the nanotech. It's that the Primer is a relationship, not a syllabus — patient, genuinely curious about its reader, and built around exactly one person.

That's the north star, and it is less of a stretch than it used to be. Anyone reading this has more of the world's knowledge within reach than any scholar in history. What almost nobody has is someone to teach them it: a tutor who knows what you already understand, notices when you're bluffing, and is still there next year. That was something you bought with money, or went without.

Most of us were schooled for a while. Being educated is a longer project, and nobody hands you the tutor for it. primer was prompted by one narrow problem — staying current in a field that keeps moving — and it is driven by a much less narrow one: wanting to know how mountains get made, and what counterpoint actually is, and why the cat does that.

So what it chases is the part that is reproducible. A tutor that knows where you are, what you're reaching for, and the way you like to be talked to. One that teaches when you tug on a thread, not when a curriculum decides it's time. One whose lessons are yours to keep: they live in your own repo, they outlast the session, and the picture it holds of you gets a little truer every time you show up.

A book that will teach anyone anything, patiently, for as long as they stay curious, was fiction when Stephenson wrote it. It isn't fiction now.

What this is

Implemented as a Claude Code skill, primer runs narrative, calibrated lessons against a persistent, evidence-backed learner profile and captures every session as a durable markdown artifact. Any subject. Geology, orbital mechanics, how cats regulate body heat, the combat math for a role-playing game you're designing, Italian grammar, distributed systems. The intake interview discovers your ability and decomposes your goal; it doesn't assume a curriculum, so there is nothing for the subject to fit into.

Running it takes Claude Code, so that part is technical. What you point it at is not.

Class and instance

primer is split in two:

  • This repo — the public core ("the class"). The engine: the skill, the protocols (primer/), and the instance templates. It holds zero personal data — including no lessons. Clone it and pull updates as the community improves it.
  • Your private data repo ("the instance"). Your profile, depth markers, calibration log, and lessons. Private, and git-synced across your machines. Created from the core by init.

This is why your data can be rich (real stack, real goals) without ever leaking: it lives only in your private repo. Lessons are personal too — they're calibrated to you, so they live in the private instance alongside the profile. Publishing a lesson is a deliberate, separate step (a derivation skill that turns a personal lesson into a sanitized public artifact is planned), never the default.

Install & first run

You need Claude Code, in a local session — the terminal CLI, or the Code tab of the desktop app with its environment set to Local. Cloud, Cowork and the Chat tab can't reach your own machine, so primer won't run there.

The easy way

Paste this into a Claude Code session and it will do the rest — checking what you already have, installing what you don't, and walking you through the parts that need you. No git knowledge required, and no GitHub account unless you want a backup.

Read https://voidnologo.com/primer/agent-setup.md and follow it to set up primer
on this machine. Walk me through anything you need from me.

That points it at agent-setup.md (source) — a plain-language runbook you're welcome to read yourself first.

Or do it yourself

git clone https://github.com/voidnologo/primer ~/primer
cd ~/primer && ./tools/install.sh      # symlinks the repo as the `primer` skill
~/primer/tools/init-instance.sh        # scaffolds your private data repo

Restart Claude Code so it picks up the new skill, then:

/primer init                # one-time: intake interview, builds your profile
/primer plate tectonics     # run a lesson on anything you like
/primer index               # show your topic map

init-instance.sh scaffolds your data repo locally and prints the git/gh commands to push it somewhere private. Those are optional — primer works fine with a local-only folder on one machine. A private remote is for backup and for syncing to a second computer.

Second machine

Clone your private data repo, then point that machine at it:

./tools/init-instance.sh <path-to-your-data-repo-clone>

It detects the existing instance and only writes that machine's pointer (~/.config/primer/config).

Privacy hardening (recommended)

primer never auto-reads a work codebase — but that is an instruction the model follows, not a wall. For defense in depth, add a deny rule to your global Claude Code settings (~/.claude/settings.json) so the tools physically can't read proprietary paths during a session. Adjust the paths to your machine:

{
  "permissions": {
    "deny": [
      "Read(//Users/you/Work/**)",
      "Edit(//Users/you/Work/**)",
      "Bash(cat //Users/you/Work/**)"
    ]
  }
}

This is belt-and-suspenders on top of the skill's own rule (the engine still redirects work-specific scenarios to canonical analogs). Stack-aware framing comes from your profile and what you say in the conversation, never from reading the code.

Subcommands

  • /primer init — first-time setup: intake interview, builds your profile
  • /primer <topic> — start an interactive lesson
  • /primer next — suggest what to learn next
  • /primer recalibrate — deep profile review (a lighter one runs automatically when the evidence warrants it)
  • /primer review — interleaved spaced-retrieval warm-up from prior lessons
  • /primer resume — pick up an in-progress lesson
  • /primer view [lesson] — open a lesson's visual page (figures, faded reveals, explorables)
  • /primer update — get the latest engine and migrate your data repo (no git knowledge needed)
  • /primer index — show topic-index tree with status
  • /primer profile — show or update your profile
  • /primer suggest <goal> — propose a multi-lesson track for a stated goal

Staying up to date

/primer update does both halves in one step: fast-forwards the engine and adds anything new that your private data repo is missing (a release that adds a state file would otherwise leave your instance erroring out). You don't need to know git — and it refuses rather than guesses if your checkout has local changes, so nothing of yours gets discarded.

You don't have to remember to check. primer looks once a day, at the moment you run it, and prints a single line if something is waiting. Offline or on a fork, it stays quiet rather than nagging or erroring.

Where it runs

primer is a Claude Code skill, so it works anywhere Claude Code reads your local skills: the terminal CLI, the desktop app, and IDE extensions. The desktop app is the nicer place for the visual layer — the lesson's view page is a local HTML file you click open, so a real browser renders the figures and explorables instead of ASCII in a terminal.

Two limits worth knowing. Cloud and Cowork sessions don't read ~/.claude/skills/ — they load skills from your claude.ai account, and they can't reach your private data repo or open a file:// page on your machine, so primer is a local-session tool by design. And your instance lives on the machine you're on; syncing it across machines is a git pull in your data repo (or /primer update, which leaves your data alone but tells you what's missing).

Design principles

The full set and the engineering rationale live in docs/engineering/GOALS.md and docs/engineering/DECISIONS.md. The most load-bearing:

  • Personal, calibrated, evidence-backed. Depth markers carry confidence + evidence; the system knows what it has seen you do vs. what it assumed. Intake discovers ability and goal; the feedback cycle keeps the profile true.
  • Senior peer, not teacher. Lessons read like a senior engineer talking to a colleague (register is calibrated per learner). No motivational fluff.
  • Productive struggle over fluent answers. Every lesson forces prediction or critique before the explanation lands. Figures work the same way: you get the diagram with the causal step blanked, and the answer stays behind a gate until you've committed to a prediction.
  • Currency is non-negotiable. The canon (primer/source-canon.md) is a vetted floor, not a ceiling — every lesson searches for current sources beyond it; a stale-list is the guardrail.
  • Private by architecture, never proprietary. All personal data — profile and lessons — lives only in your private instance; the skill never auto-reads a work codebase. Publishing a lesson is a deliberate future derivation step, not a default.

Developing primer

Engineering happens against the north star in docs/engineering/ using the session-start / session-end skills, which track the why (decisions, tradeoffs) alongside git's what. See REQUIREMENTS.md for the original design contract (historical; the living design record is now docs/engineering/ + primer/).

Contributing

The public core is the reusable part. Other learners clone it and bring their own private instance — fork or PR improvements to the engine; never commit personal data here.

License

MIT — see LICENSE.

Ver o original no GitHub

Bom para

Relacionados