Free tool

Reading time calculator

Paste a lesson or any text and see how long it takes to read, section by section, at the average adult reading speed or your own. It reads Markdown the way a learner does: link text counts, link addresses and images don’t, and code is up to you.

Free, no sign-up. Nothing you type leaves your browser.

Your lesson

Lesson text (Markdown or plain text)

# Branches in Git

In this lesson you'll create a branch, commit a change on it and merge it back into `main`. Set aside about half an hour, including the exercise at the end.

## Why branches?

A branch is a separate line of work in the same repository. While you work on a branch, `main` stays exactly as it was, so the version everyone else uses keeps working. When your change is ready and checked, you merge it back.

Teams use branches for almost everything: a new feature, a bug fix, even a typo in the documentation. Several people can work at the same time without overwriting each other's changes, and every change can be reviewed before it reaches `main`. If an idea doesn't work out, you delete the branch and nothing else is affected.

You'll see names like `feature/contact-form` or `fix/login-error`. The name doesn't change how Git treats the branch, but a clear name tells your team what the work is about before they open it.

## Create a branch and commit

Open a terminal in your project folder. Make sure you're on `main` with nothing waiting to be committed, then create a branch and switch to it:

```bash
git switch main
git status
git switch -c add-contact-page
```

Git copies nothing when you do this. A branch is a pointer to a commit, which is why creating one is instant, even in a large project. Now make your change:

1. Create `contact.html` with a heading and a short paragraph.
2. Run `git add contact.html` to stage the new file.
3. Run `git commit -m "Add contact page"` to save it on your branch.
4. Run `git log --oneline` and check that your commit is at the top.

## Merge it back

Switch back to `main` and merge your branch into it:

```bash
git switch main
git merge add-contact-page
```

### If the merge conflicts

A conflict means the same lines changed on both branches since they split. Git stops and marks those lines in the file. Open it, keep the version you want, delete the markers, then run `git add` and `git commit` to finish the merge. If you're not sure which version to keep, ask: losing a colleague's work is harder to fix than a conflict.

## Check your work

- `git log --oneline` on `main` shows your commit.
- `contact.html` is in your project folder on `main`.
- `git branch` still lists `add-contact-page`. Delete it with `git branch -d add-contact-page`.

Sections are its ## and ### headings. Text before the first one is the introduction.

Reading speed (words a minute)

Second language 200Average 238Skim 300Custom

238 is the average for adults reading non-fiction in English (Brysbaert, 2019). 200 and 300 are rules of thumb.

Count code blocks

Flag sections longer than (minutes)

A rule of thumb, not a research figure. Leave it empty to flag nothing.

Reading time

2 min at 238 words a minute

383words

6sections

3 minreading aloud

Reading aloud uses about 150 words a minute, a rule of thumb for presenting with pauses. 15 words of code left out.

By section

Section	Words	Time
Introduction	33	10 s
Why branches?	133	35 s
Create a branch and commit	106	25 s
Merge it back	13	5 s
If the merge conflicts	67	15 s
Check your work	31	10 s
Total	383	2 min

How to use the calculator

Paste your lesson. Markdown or plain text both work. In Markdown, every ## and ### heading starts a new row in the table.
Choose a reading speed. The default is 238 words a minute. Pick 200 for a group reading in a second language, 300 for skimming, or enter your own.
Decide about code. Code blocks are left out unless you tick “Count code blocks”.
Read the table. Each section shows its words, its reading time and a bar for its length. Sections over the limit you set are flagged.

Copy the table as Markdown for a lesson plan, or download it as a CSV file for a spreadsheet.

How reading time is calculated

Reading time is the number of words divided by the reading speed. The real work is counting the right words, so the calculator counts what a reader actually reads:

Counted: headings, paragraphs, list items, table cells, quotes and callouts, the text of links, and inline code such as git status.
Left out: Markdown symbols, link addresses, images, HTML tags, bare URLs, comments and front matter.
Your choice: fenced code blocks.

A word is anything between spaces that contains a letter or a digit, so “e.g.”, “238” and “end-to-end” each count once. Sections start at each ## or ### heading, and the text before the first heading is the introduction. Section times are shown to the nearest five seconds and the total to the nearest minute, because nobody reads to the second.

Why 238 words a minute

In 2019 Marc Brysbaert brought the research on reading speed together in a review and meta-analysis. His best estimate for adults reading non-fiction silently in English is 238 words a minute; fiction is a little faster, at 260. You’ll see other figures, often round numbers like 200, 250 or 300. Brysbaert’s is the best-supported average we know of, so it’s the default here.

Two things slow real learners down. Reading in a second language is slower, by how much depends on the reader, so the 200 preset is a rule of thumb rather than a measurement. And learners don’t just read a lesson: they reread, look things up and try the commands. Treat the result as the least time a section needs, not the time it will take.

Why reading time per section matters

A total of “12 minutes” hides the shape of a lesson. Six sections of two minutes and one long block with a short tail can have the same total and read nothing alike. Long stretches without a heading, an example or a task are where attention drifts and readers start to skim, and that’s easy to miss when you wrote the text yourself.

Per-section times show where to split. Add a heading where the topic changes, turn a long explanation into a worked example, or stop for a question. Short, well-named sections also make feedback more precise: in Chalkenso, learners say which section they got stuck on, and “section 3 of 4” is more useful when section 3 is one idea rather than five.

A worked example

A Git lesson for a programming bootcamp, about 1,850 words, at 238 words a minute:

Section	Words	Reading time
Introduction	120	30 s
Why branches?	310	1 min 20 s
Create a branch and commit	880	3 min 40 s
Merge it back	390	1 min 40 s
Check your work	150	40 s
Total	1,850	8 min

The lesson takes about 8 minutes, and nearly half of that is one section: “Create a branch and commit” has 880 words, 48% of the lesson, and is the only one over the 3-minute flag. It does three jobs: setting up, the commands, and what a branch really is. Split at those seams, it becomes three sections of a minute or so, each with its own heading and something to try. For a group reading in a second language, set the speed to 200 and the lesson takes about 9 minutes; presented aloud at 150 words a minute, about 12.

Tips

Add time for doing, not just reading. Exercises, quizzes and running code take longer than reading about them. The course workload calculator adds them up week by week.
Check how hard the text is, too. A short section full of long sentences reads slower than its word count suggests. The lesson readability checker scores each section the same way.
Measure your own group. Time a few learners on one section and use their speed as the custom value.
Say it at the top of the lesson. “About 8 minutes to read, 20 with the exercise” helps learners plan, and gives you an expectation to check against.

Questions people ask

How long does it take to read 1,000 words?

About 4 minutes at 238 words a minute, the average for adults reading non-fiction in English. At 200 words a minute, for example in a second language, it takes 5 minutes. Read aloud at about 150 words a minute, it takes nearly 7.

How many words is a 5-minute read?

About 1,200 words at 238 words a minute (1,190 to be exact), or 1,000 words at 200. A 10-minute read is about 2,400 words of prose, before any time for code, exercises or questions.

What reading speed should I use for learners?

Start with 238 words a minute, the average from Brysbaert’s 2019 meta-analysis of silent reading in English. Use 200 if most of your group reads in a second language or the topic is new to them, and your own number if you have timed your group.

Does the reading time include code?

Not by default. Code isn’t read like prose, so the calculator leaves code blocks out and tells you how many words of code it skipped. Tick “Count code blocks” to include them. Inline code inside a sentence always counts.

How is the reading aloud time worked out?

At about 150 words a minute, a common rule of thumb for presenting with pauses. Use it to plan a talk or a recorded walkthrough, and time a rehearsal if the slot is tight.

Is my text stored anywhere?

No. The calculator runs in your browser; nothing you paste is sent to a server or saved.

More free tools

All free tools →

Readability

Do this for every lesson, every group

Chalkenso is where courses are designed and improved: instructors note what happened on the exact passage, learners say where they got stuck, and AI drafts the next version for you to approve.

Join the waitlist How it works

Join the waitlist