hibi日々

Why hibi exists

Ask an AI assistant for help with code and you'll get working code. At work, that's exactly what you want. When you're learning, it gets in the way. You read the answer, it makes sense, you paste it in, and a week later you can't write it on your own. You also can't tell which parts you understood, and neither can the assistant, because it never asked.

hibi is built for learning. It holds the solution back on purpose and gives you more help as you keep trying. It checks your work by running it. And it keeps track of what you've shown you can do, so after a few weeks it knows where you're solid, where you're guessing, and what you haven't practised in a while.

Install

hibi is published on npm, so once you have Bun it takes one command.

What you need

With Bun

bun install -g @hwgo1/hibi

From source

If you want to read or change the code, install from the repository instead:

git clone https://github.com/hwgo1/hibi
cd hibi
bun install
cd packages/cli && bun link && cd ../..
bun link @hwgo1/hibi

First run

Open a folder with your code and run hibi. The first time, it asks you three things:

Language comes first, so everything after it is already in your language. hibi tests the key before saving it and hides it on screen once you paste it. It also picks a recommended model for you, which you can change later with /model.

Your first five minutes

1. 1
   Open a project.

   cd into a folder with your code and run hibi. The first time, it reads the project to find out the language, how the tests run, and which files you wrote.

2. 2
   Say what you want to learn.

   “I want to learn Go” and “what is a variable?” both work. If you mention a goal, hibi saves it and picks up from there next time.

3. 3
   Ask for an exercise.

   hibi writes the task and tells you which file to work in.

4. 4
   Try it, then say you're done.

   hibi runs your tests. If you get stuck, ask for a hint and watch it go from “look here” to “this is the problem”.

5. 5
   Type /help.

   You'll see examples of what to ask, plus the two commands you'll use most.

Documentation

Commands

Most of the time you talk to hibi in plain words. Commands are for when you want to look at what it has recorded or change a setting. /help all lists them in these same groups.

Command names stay in English whatever language you pick, since you're the one typing them. Their descriptions in /help follow your language.

Hints

When you're stuck on an exercise, help comes in three steps. hibi shows which one you're on above its answer, as “hint 1 of 3”.

1. step 1

   Points to the part of your code where the problem is and names the idea involved. It doesn't say what's wrong.

2. step 2

   Names the problem and shows exactly where it is. It doesn't write the fix.

3. step 3

   Shows the fix, explains why it works, and gives you a similar problem in a different setting to solve on your own.

Checking your work

When you say you're done, hibi runs your project's own test command. Which one depends on the project:

It finds the command when it first reads your project and never takes it from the conversation, so nothing written in a file can change what runs.

Questions before answers

Sometimes hibi asks you something before it explains or runs anything. There are three kinds of question, and each one comes at a natural pause.

You can skip any question by carrying on with what you were doing. hibi asks at most once every four exchanges and six times per session, and if you skip two in a row it stops asking for the rest of the session. To turn questions off, use /prefs unsolicitedHints never.

Quizzes

Running code doesn't show everything. Knowing when to use a lock is different from being able to write one, so hibi also asks multiple-choice questions.

Goals

Tell hibi what you're working toward: learning a language, getting ready for interviews, building a project. It saves that and brings it up when you come back (“Last time you were working on: learning Go”).

When you ask what to do next, hibi suggests two or three topics from your record:

• ones you've never covered
• ones you've tried but aren't solid on yet
• ones you said you know but never showed
• ones you haven't touched in about three weeks

It works these out fresh every session. There's no fixed syllabus, because a saved plan would be out of date the moment you learned something.

If you already know something it suggests, say so. hibi takes your word for it and moves on without testing you.

What hibi knows about you

hibi keeps two kinds of records.

Where each piece of evidence comes from

A passing test is a fact. A right answer on a quiz is an observation. The model deciding your code looks right is an opinion. Each entry in the log says which one it is, and that decides how much it counts.

On top of that, solving something on your own counts in full, and solving it after seeing the fix counts about a third. Asking for the answer outright halves that again.

Confidence

Every estimate comes with how much hibi trusts it. A low score with low confidence means hibi doesn't know much about you on that topic yet. hibi never shows a score without its confidence.

mastery
  goroutines: 0.62 (confidence 0.40, 3 direct)

What hibi has noticed

Once there's enough evidence, hibi starts to notice patterns in how you learn. /signals lists them, with how sure it is about each:

observed tendencies
  self-assessment = tends to overestimate (55%, 12 events)
  hint-depth = usually unblocks at the first hint (50%, 10 events)
  these are guesses — declare the opposite with /prefs to override one

The first line compares what this learner predicted before running the tests with what happened: they usually expected to pass before they actually did.

These are guesses, and they only show up after at least eight related events. Anything you set in /prefs always wins over something hibi guessed.

Topics

Topics form a tree that grows as you learn. “linked list”, “linked lists” and “lista encadeada” all count as the same topic.

Progress on a specific topic also counts, a bit less, toward the broader ones above it. Solving something about goroutines adds a little to concurrency too.

Disagreeing with a number

If hibi says your score on pointers is 0.2 and you think that's wrong, tell it. The number won't change because you asked. hibi offers a quiz or an exercise on pointers instead, and the result moves the score.

Disagreeing costs nothing and never lowers a score by itself. If you dispute the same topic again, the next result counts a little less. hibi still accepts the dispute and offers another quiz.

Undo and forget

Both work by adding a note to the log that cancels the earlier entries, so your history stays complete and can still be recalculated.

Settings

Change these with /prefs <name> <value>.

There's no setting for how much hibi holds back. You can change how it teaches, but the step-by-step hints always apply.

Where your data lives

Everything stays on your computer, in a folder called .hibi in your home directory:

~/.hibi/
  credentials.json    your API key, readable only by you
  profile.json        your preferences, goal and scores
  concepts.json       your topic tree
  evidence.jsonl      the log of everything that happened
  repos/<id>/
    repo.json         what hibi learned about that project
    session.json      the current exercise, hints and questions

Your scores, topics and log are shared across projects. The session and project details belong to each project.

The only thing that leaves your computer is the conversation with the AI company you picked, sent with your own key.

To start over completely, delete the folder:

rm -rf ~/.hibi

How it's built

hibi has no AI model of its own. It runs the conversation around the model you choose: the teaching rules, the tools the model is allowed to call, and the record of your progress.

Each project gets a small background process that holds the session. The terminal interface is a thin client that talks to it over a local socket, so a future editor panel could join the same session.

hibi doesn't rely on the conversation text to keep track of things. The current exercise, the hint step and your history are saved to disk and rebuilt for every message. You can clear the conversation in the middle of an exercise and hibi still knows where you were.

The code is TypeScript on Bun, split into three packages. core is the tutor and has no disk or network access of its own; everything goes through small interfaces. daemon is the background process. cli is the terminal interface.

Where the project is

hibi is at 0.1 and still experimental. Everything on this page works, and its author uses it every day.

The numbers that decide when a hint goes up a step (two attempts, eight minutes, three minutes before the first hint) and how often hibi asks questions are first guesses. Nobody besides the author has tested them yet. If hibi helps you too early or too late, open an issue and say which exercise it was.