Page four · Replicate

Run it yourself. This afternoon.

Everything on this page — the bot, the chatrooms, the checklists — is equipment. The first section is the method. If you learn only one thing on this entire website, learn this.

Before the setup: learn the one skill

"We restrain anything breaking the focus — everything that breaks the train of thought. We restrain."

Your train of thought is your current task-relevant thinking: the live thread of this connects to that connects to this that understanding is actually made of. When you're deep in hard material you're holding a whole structure in your head — where you are, what you just understood, what comes next. That structure is fragile, and it is you-thinking.

The phone was never after your eyes. The glance is just the weapon. The thread is the target. This is why you can glance at your phone for half a second and lose twenty minutes: the glance cost nothing — the derailed train takes twenty minutes to get back to speed. You weren't punished for looking. You were punished for letting the thread stop.

So here is the method's real rule, beneath the promise: the train does not stop. Notifications are trying to stop it. People walking past are trying to stop it. Your own boredom is trying to stop it. No stopping on the train.

Meaningful and meaningless: same treatment

During a session, your phone carries two kinds of pings — the bot's spam and your real life. Treat every notification as if it were spam. That's the whole discipline in one sentence: the crush's text and the bot's nonsense get identical treatment — nothing — until the break. You're not ignoring your people; you're deferring them (they get you fully, minutes from now, instead of a distracted half-reply). The meaningless flood exists precisely to train the muscle you'll use on the meaningful ones: build the skill where the stakes are zero, own it where the stakes are real.

Technique 1 — The verbal anchor

When a ping lands and you feel the thread start to go: say your current thought out loud. Under your breath is fine. "So if this is true, then the next step has to be—"

A thought you're speaking is a thought that's shielded — speech occupies the exact mental channel a distraction would hijack, and it gives the thread a physical handhold. The ping has to fight your own voice. Your voice wins.

Technique 2 — The 3-second rewind

The thread will snap sometimes, especially early. When it does: don't restart, don't panic, and don't check the phone "to reset." Close your eyes and ask one question: what was I thinking three seconds ago? Then re-enter the thread exactly where you fell off.

Three seconds is the right distance — far enough back to find solid track, close enough that you haven't lost the section. The derailment costs you three seconds instead of twenty minutes.

Emotional restraint — the third front

Distraction attacks on three fronts, and only one of them is visual: eyes — the glance, handled by the promise. Thoughts — the drift, handled by the anchor and the rewind. Emotions — the tilt, handled here.

Frustration at the noise, the little spike of what if it's important, boredom, the urge to quit the session — during a session, emotions are distractions. Same treatment: notice the feeling, name it if you have to, and don't obey it. You're not suppressing it — you're declining to let it drive. (This is the same emotional regulation the rank-1 players run under a roaring crowd. It's trainable, and this is the trainer.)

What failure is — and isn't

A glance is not failure. It doesn't matter if you look — if you don't care. A glance you recover from in three seconds, thread intact, costs almost nothing. Log it honestly and move on.

Derailment is the only real failure — looking at the phone and letting it take the train: unlocking, checking, drifting, the twenty-minute wound. And even that failure has a protocol: no guilt, no reflection mid-session. Twenty seconds of breath, then lock in harder. When you drift, return without guilt. When you fail, don't reflect — restart.

Every technique above serves one sentence, made before the session, kept absolutely during it: "I refuse to look once." Guard the thread. Keep the promise. The phone becomes irrelevant — not a phone you're heroically resisting, but a phone you forgot because you were busy.

---

The setup — five things. You already own four.

1. Your phone. The daily one. The enemy you know.
2. A flood of meaningless notifications. Unpredictable timing — that matters more than anything. Two free ways to get it are below. (Rates and how to choose them: the reference card.)
3. Vibration OFF. The training channels are sound and light. Buzzing through the desk adds difficulty with no added benefit — turn it off in settings before anything else.
4. The hardest material you own. Not the easiest — this is half the method. A fully loaded mind has no spare room to notice a phone. Easy work leaves your attention idle, and idle attention checks phones.
5. A timer. 25 minutes, two sessions minimum on Day 1.

Configure the phone once: notifications wake the screen · notification sound on for all apps (ringer days) · batch/scheduled notification summaries disabled — pings must land as they come · real apps keep their notifications on, in and out of sessions. If you'd silenced apps to cope, turn them back on — that's the old world, and you're leaving it.

Positioning — in front of you. On purpose.

Phone face-up, right next to your study material — left or right, your pick, in a comfortable spot — inside your natural line of sight. Close enough to see it light up without turning your head. Upright or flat, on standby, so arriving notifications wake the screen where you can see it.

Not buried. Not in a drawer. Not face-down. Every other focus method hides the phone; hiding is the OLD WAYS, and you know from the Theory page why it fails — the connection can't be severed, only blinded, and a blinded brain monitors harder. Present, visible, and ignored is the whole training condition.

Run your first sessions at your own desk, alone. The library and the café come later — that's the victory lap.

---

Two ways to get the flood. Pick one and start today.

The method needs one ingredient you can't buy: meaningless notifications, unpredictable, relentless. Two free ways to manufacture them. Version A takes ten minutes and zero skill. Version B takes one setup evening and gives you total control. Both end in the same place.

Version A — Public Chatrooms (start in 10 minutes)

Telegram is full of massive public group chats that never stop talking. You're going to weaponize their noise.

Setup: Download Telegram. Spend 10 minutes joining as many high-traffic public chatrooms as you can find — any language, any topic; you're not going to read them. Foreign-language groups are ideal: guaranteed meaningless. Allow notifications from every group, waking the screen, with sound. Vibration off. Batch notifications off.

The studying execution:

1. Phone positioned per the setup — face-up, beside your work, in view.
2. Hardest material open. Timer set: 25 minutes. No music — you haven't earned it yet.
3. Say the promise: "I refuse to look once."
4. Study. The chatroom pings rain down. Every single one gets ignored — and here's Version A's hidden training bonus: your real apps are still pinging too. You know your Discord sound. You know your Instagram sound. When one of those lands in the flood, it gets the same treatment as the foreign-language spam. That's the exact muscle this method exists to build.
5. When a ping grabs at you, run the strategies from the skill section: close your eyes a beat and open them on your work · repeat what you were thinking 3 seconds ago · say "ignored" and keep moving · talk yourself through the material. After about an hour, your brain stops noticing and you won't need any of these. They're the training wheels; habituation is the bike.
6. Session ends: fill in the self-report. 5-minute break — now you may check your real messages. Then again.

Honest trade-offs: running in minutes, zero technical skill, chaotic and unpredictable (which is good) — but uncontrollable (rates swing with the chatrooms' mood), you're a member of strange groups, and cleanup means leaving them all later. Version A is the perfect first afternoon. Most people who stay switch to B.

Version B — The Telegram Bot (one evening of setup, then it's yours forever)

A small script you host yourself that sends you meaningless pings on a schedule you control. Same training, laboratory precision.

Setup: Prepare something you actually want to learn — have it ready before you touch the tech. Read the skill section; it carries over exactly. Download Telegram, host the bot script below, and aim it at yourself. Keep your normal notification settings for all real apps. Configure: notifications wake the phone · sound for all apps · batch notifications disabled. Test run: message /test to the bot, lock your phone, wait ~10 seconds. If the screen wakes with a sound, you're operational. (Kill switch: /stop, or Notifications → Telegram → off.)

The studying execution: identical to Version A from the promise onward — that's the point. The flood source changes; the method never does. What B adds: controlled rate (pick from the reference card and tune) · controlled randomness (unpredictable intervals matter more than volume — a metronome gets habituated for free; randomness makes the reflex do the work) · progression (as levels rise, adjust rate instead of hunting for louder chatrooms) · privacy (no strange groups, nothing to clean up — your flood, your rules).

No bot, no chatrooms? The flood is anywhere you can make it

Any cue that carries no meaning works. Proven alternatives: a friend with a mission (they text you nonsense every 20–30 seconds during your session — do it together and trade sessions) · any tool that fires notifications (interval timers, reminder apps) on a constant or random schedule · a junk app you don't care about, notifications maxed. For tonight, the fastest flood is the best flood.

Whichever version: the method is the promise and the thread. The flood is just weather.

---

Notification rates — the reference card

There is no magic number, and we're not going to invent one. Two honest rules govern everything:

Rule 1 — diminishing returns. More volume is not deeper training. On your first trial, somewhere around 200–300 pings in the first hour gives the reflex plenty to extinguish against. After the collapse, most people scale back to roughly 60 an hour on a flash-only sequence — because past a point, extra pings add annoyance, not training. Going to 1,000 an hour, or adding vibration, raises the difficulty without raising the benefit. Spend the difficulty budget where it pays: unpredictability, harder material, louder environments — not raw volume.

Rule 2 — you can stop at any time. The rate is not a commitment. The moment the flood turns from annoying-and-fading to suddenly-unbearable, that's fatigue — end the session. Stopping is in the protocol.

Tuning rules: change one thing at a time (rate, sound profile, or environment — never two in one session, or your self-report can't tell you what worked) · read the Restraint score, not your mood (if the effort of not-looking is ≤2 by session's end, you've earned a raise; if it's ≥5, hold or drop) · comfort mode is legitimate (a gentler flood you actually run beats a heavy flood you quit — the promise is the training; the rate is just weather) · real notifications count toward the experience but not the number.

---

The progression system — two days, then it's installed

This is a progression, not a timetable. Nobody schedules you and nothing unlocks on a calendar — every rung is self-initiated: you run the next block when you decide you're ready, and your own restraint score tells you when that is. Day 1 builds the skill under full fire. Day 2 proves it transfers — and then finds out how far it goes. Every study block is 25 minutes unless it says otherwise; every block ends with a self-report (thirty seconds — the curve is the reward).

Day 1 — Priming (ringer · the hard day)

Today is the most resistance you will ever feel from this method. It's all downhill after.

1. Your phone can vibrate — disable that in settings
2. Download Telegram
3. Spend 10 min joining chatrooms (or arm the bot — either flood works)
4. Allow notifications from all groups
5. Allow notifications to wake the phone screen
6. Place the phone in front of you — and don't look once
7. Study 25 min on ringer
8. Self-report · 5-min break
9. Study 25 min on ringer
10. Self-report · 5-min break
11. Try music — study 25 min on silent
12. Self-report · 5-min break
13. Disable Telegram notifications in settings
14. Music — study 25 min on silent
15. Self-report

What just happened: two ringer rounds trained sound + flash + presence at once. The silent rounds transferred the skill to flash alone — and the music was earned relief. Steps 13–14 are the reverse cue: real notifications only, flood off — notice how quiet your head is around them already.

Day 2 — The Limit Test (how long can you study?)

Yesterday was training. Today is limit-testing: see how far you can go.

1. Allow Telegram notifications again
2. Place the phone in front of you — don't look once
3. Study 25 min on ringer (should feel embarrassingly easy compared to yesterday)
4. Trial report · 5-min break
5. Music — study 25 min on silent
6. Trial report · 5-min break
7. Remove music — study as long as you can, on ringer
8. Trial report · extended break
9. Music — study as long as you can, on silent
10. Trial report · extended break

Steps 7 and 9 are the whole point of Day 2. No timer as a wall — the 25-minute block was scaffolding, and today you find out what's underneath. The founder's Day 2: 106 unbroken minutes, ringer, no music. That's the number on the board. (And remember the fatigue rule from the safety block: the founder also found his ceiling that day. When sudden aversion hits, the session is over — log it and be proud of the number.)

After Day 2 — maintenance, not dependence

The flood is the entrance, not a leash. You don't need it every session forever: feeling scattered? Run the flood for a session — like a heavy warm-up set. Real notifications land while you study; they get the same treatment as fake ones. That's the entire point. Reply when the work is done — 5 seconds vs 4 hours changes nothing. The trained reflex fades without occasional use. Reinforce it with a flooded session now and then, or notice it quietly maintaining itself every time a ping dies unanswered on your desk.

Limit testing — the ladder for people who caught the itch

• The 106 Wall. Longest unbroken ringer session, no music. Founder's mark: 106 minutes. Log your best; beat it; post it.
• Environment climbing. Desk → living room with people in it → library → busy café. Same phone, same flood. The environment is the difficulty slider — participant 03 locked in his first time in a crowded public space with 150 pings in 30 minutes.
• Salience climbing. Assign your most dangerous apps their loudest sounds, or raise the rate — remembering the diminishing-returns rule: past a few hundred an hour you're adding annoyance, not training.
• The deception run. After a week, have a friend secretly kill the flood mid-session. Check your numbers after. If focus held with zero pings arriving — congratulations: it was never the flood. It was you.

Rule for every rung: the promise never scales. Rates scale, environments scale, durations scale — "I refuse to look" stays absolute at every level.

---

The coached variation — install it in a friend in twenty minutes

Everything above is the solo path. This is the two-person one — the exact procedure behind Case 3, where a participant with zero preparation, in a crowded public university, never looked at his phone once, starting from trial one. Total teaching time: 10–20 minutes. You are the coach; your friend is the participant. It works face-to-face at a library table this afternoon.

Stage 0 — Setup (before any instructions)

1. Participant seated with engaging material they actually need to learn — something that demands notes, not busywork.
2. Their phone goes on a stand (or propped) directly beside their work, face-up, in view.
3. With their consent, configure the phone — talk them through it rather than grabbing it: notifications ON for all apps · notifications wake the screen · brightness up · one standardized notification sound for everything. On Android, set all ringtones to the same sound (a screen-wake helper app like Glimpse Notifications covers models that won't wake). On iPhone you can't customize per-app notification sounds — the workaround is a Focus mode allowing only your chosen apps, sharing one sound.
4. Invite their phone to your bot (they download Telegram, you aim the flood at them). Send a test ping; confirm the screen wakes.
5. Why standardized sound matters (found by accident, kept on purpose): when every ping sounds identical, there's no "maybe that one's real" loophole — habituation runs much faster. You can skip it, but mixed meaningful/meaningless sounds mean slower adaptation and more effort for the same result.

Stage 1 — The rules speech

Tell them exactly what's about to happen — full disclosure is the protocol: "You're going to receive a lot of notifications. Most are from Telegram, but I'll also text you on Instagram and WhatsApp — real apps. I don't care what ping it is: you do not look at your phone. Don't let your eyes flick to it, don't let your head tilt toward it, don't react to it, don't look in its general direction."

• Rule 1 — never respond to a notification. If you catch yourself looking, say so immediately. If you catch yourself mid-reflex — head already turning — say that too. Failures are data, not shame; reporting them is part of the task.
• Rule 2 — I will try to get your attention during the session. Don't respond to me either — or to anyone in the background — unless I put the finished timer in front of your eyes.

Then have them repeat both rules back to you. Don't skip this — saying the rules out loud is half of installing them.

Stage 2 — Observational learning (the shortcut that makes trial 1 work)

1. They put earphones in (the room is loud — that's intentional) and prepare to take notes.
2. Show them ~4 minutes of video of someone running the method — pings landing, none answered. Instruct them to write down every physical, mental, and verbal strategy they can spot. Tell them plainly: "this is how everyone so far has managed not to look on their very first try."
3. Teach the train of thought: send one ping to their phone and let them watch it light up. "When it lights up, you can close your eyes." Then the rules of the train: your brain holds a fragile thread of thinking; notifications — and people — exist to stop the train; you stay on the train by remembering what you were thinking three seconds ago; no stopping on the train.
4. Point out what's already true: pings have been landing this whole time, and they've been ignoring them. Show a later-session clip at 10× speed and ask them to describe what they saw. Tell them: "in the first 30 minutes you'll struggle; after that, you look like this."

Stage 3 — Exposure, then trials

1. With the flood live, give them a short throwaway test (a 30-answer Stroop test works) — the score is irrelevant; it exists so their first minutes of ignoring pings happen under a task load, in noise. (Replicating formally? Run your baseline test before any instructions instead.)
2. They start their own timer — 25 minutes, their finger on the button. Self-initiation matters here too.
3. Trial sequence, one report after each: ringer → ringer → silent → deception (kill the flood without telling them). If the deception trial's numbers hold with nothing arriving — show them. That's the moment they understand it was never the flood.

The whole session, reports included, fits in about two hours. Then send them here — the site can coach them solo from Day 2, and their numbers belong on the dataset.

---

Host your own flood — the bot script

This bot sends you meaningless Telegram notifications at a random rate you control. It runs on your own computer — free, private, no third party. One-time setup: about 15 minutes.

Step 1 — Create your bot (5 min, in Telegram)

1. In Telegram, search for @BotFather (the official one, blue check) and open it.
2. Send /newbot. Give it any name (e.g. my restraint bot) and any unique username ending in bot.
3. BotFather replies with a token that looks like 1234567890:AAE...xyz. Copy it. Treat it like a password.
4. Open a chat with your new bot and press Start, then send it any message — this matters; the bot can't message you first.

Step 2 — Get your chat ID (2 min, in a browser)

Visit this address (paste your token in):

https://api.telegram.org/bot<YOUR-TOKEN-HERE>/getUpdates

You'll see text containing "chat":{"id":123456789,...} — that number is your chat ID. Copy it. (If the page shows nothing, send your bot another message and refresh.)

Step 3 — Install Python + the script (5 min)

Install Python from python.org if you don't have it (Mac already does). Open Terminal (Mac) / Command Prompt (Windows) and run pip install requests. Save the script below as restraint_bot.py and paste your token, chat ID, and chosen rate into the top three lines.

"""
restraint_bot.py — sends you meaningless Telegram notifications
at a random rate. /stop in your bot chat pauses it, /start resumes,
/test sends one immediately. Ctrl+C in the terminal quits.
You can stop at any time — stopping is part of the protocol.
"""
import random
import time
import requests

# ─── EDIT THESE THREE LINES ────────────────────────────────────
BOT_TOKEN = "PASTE-YOUR-TOKEN-HERE"
CHAT_ID   = "PASTE-YOUR-CHAT-ID-HERE"
RATE_PER_HOUR = 60   # standard start. First trial: 200-300 works.
# Past ~300/hr returns diminish fast — more is annoyance, not training.
# ───────────────────────────────────────────────────────────────

# Meaningless by design — no content worth reading, ever.
MESSAGES = ["·", "· ·", "—", "...", "␀", "nothing", "not this one",
            "still nothing", "ignore me", "meaningless", "∅", "~"]

API = f"https://api.telegram.org/bot{BOT_TOKEN}"
RATE = min(max(RATE_PER_HOUR, 1), 1000)
if RATE > 300:
    print(f"note: {RATE}/hr is past the point of diminishing returns —")
    print("      you're adding annoyance, not training. 200-300/hr is plenty.")

def send(text):
    try:
        requests.post(f"{API}/sendMessage",
                      data={"chat_id": CHAT_ID, "text": text}, timeout=10)
    except requests.RequestException:
        pass  # brief internet blips shouldn't kill a session

def poll_commands(offset):
    """Returns (new_offset, command) for the latest /stop, /start or /test."""
    command = None
    try:
        r = requests.get(f"{API}/getUpdates",
                         params={"offset": offset, "timeout": 0}, timeout=10)
        for u in r.json().get("result", []):
            offset = u["update_id"] + 1
            text = u.get("message", {}).get("text", "")
            if text in ("/stop", "/start", "/test"):
                command = text
    except (requests.RequestException, ValueError):
        pass
    return offset, command

def next_delay():
    """Random gap around the average — unpredictability is the training."""
    average = 3600.0 / RATE
    return random.uniform(0.4 * average, 1.6 * average)

print(f"Flood running at ~{RATE}/hr. /stop pauses, /test fires one. Ctrl+C quits.")
send("flood armed — lock in")
offset, running, wait = 0, True, next_delay()

while True:
    time.sleep(2)
    wait -= 2
    offset, cmd = poll_commands(offset)
    if cmd == "/stop" and running:
        running = False
        send("flood paused — /start to resume")
        print("Paused.")
    elif cmd == "/start" and not running:
        running, wait = True, next_delay()
        send("flood resumed")
        print("Resumed.")
    elif cmd == "/test":
        send("test — if your screen just lit up with a sound, you're operational")
    if running and wait <= 0:
        send(random.choice(MESSAGES))
        wait = next_delay()

Step 4 — Run it

python restraint_bot.py

Leave the terminal open while you study. Test before your first session: send /test to your bot, lock your phone, wait ten seconds. If the screen wakes with a sound — you're operational. If not: Settings → Notifications → Telegram → allow notifications, sounds on, wake screen on, and disable notification summaries/batching.

Kill switches, gentlest to hardest: /stop in the chat · Ctrl+C in the terminal · Settings → Notifications → Telegram → off.

Troubleshooting

• No messages at all → token or chat ID pasted wrong (most common), or you never pressed Start in the bot chat.
• Messages arrive silently → Telegram notification settings (see Step 4), or your phone is in a Focus/Do-Not-Disturb mode.
• pip: command not found → reinstall Python and tick "Add to PATH" (Windows), or use pip3 (Mac).
• Want it running without your laptop? Any always-on machine works (an old laptop, a Raspberry Pi, a free-tier cloud shell). Same script, same command.

---

After you run it

Log your numbers. Post them. The evidence for this method is n=4 plus everyone who replicates — you're not a customer, you're a data point. Bring your curve.