Last time we spent the whole episode out in the world -- finding your neighbourhood of the scene, climbing the on-ramp, doing a shared prompt, being generous with your credit and your kindness. And right at the end I warned you about the catch: a community is wonderful, but it cannot make the work for you. At some point you have to sit down, alone, at your own desk, and keep making things day after day, even when nobody's watching and the muse has very clearly taken the week off. That's today. This is the episode about daily practice and the creative process -- the quiet engine under everything else in this series, the thing that turns "someone who did a tutorial once" into "someone who makes things".
I'll be honest with you, this is the episode I most wish someone had given me at the start, because I got it completely wrong for years. I thought creative people were struck by lightning -- that real artists sat around waiting to feel inspired, and then produced magic. So I waited. I waited for the mood, the perfect idea, the big block of free time. And I made almost nothing. What actually changed my life wasn't a better idea, it was a boring little habit: one small sketch a day, finished or not, good or bad. So this episode is less about clever rendering and more about the machinery of showing up. Allez, let's build you a practice that survives the days you don't feel like it.
Here's the thing nobody tells the beginner: the feeling of inspiration is real, but it is not the source of the work -- it's a byproduct of it. Inspiration shows up while you're already making, almost never before. So a practice built on waiting to feel inspired is a practice built on sand. I like to make that painfully concrete, the way we've done all series long, by turning the fuzzy belief into a tiny model I can actually poke:
// the myth: work happens when inspiration strikes. reality: it's the other way round.
function willIMakeSomethingToday(state) {
const mythicalPath = state.feltInspired; // waiting for lightning
const realPath = state.showedUp && state.startedSmall; // just... started
return {
ifYouWaitForTheMuse: mythicalPath, // true maybe 1 day in 20
ifYouJustShowUp: realPath, // true every single day you choose it
truth: "inspiration arrives DURING the work, not before it",
};
}
console.log(willIMakeSomethingToday({ feltInspired: false, showedUp: true, startedSmall: true }).ifYouJustShowUp);
// -> true
Look at that realPath: it doesn't depend on how you feel, only on two things you fully control -- you showed up, and you started small. That's the whole trick, and it's freeing once it lands. You are never waiting on a mood you can't summon. On my flattest, most uninspired Tuesday in Antwerp I can still open the editor and change three numbers, and nine times out of ten, somewhere in that fiddling, the interest wakes up on its own. Motion creates motivation, not the reverse. Stop waiting to feel like it and the whole game changes.
So how do you actually build the habit? The single best structure I know is the sketch-a-day: one tiny finished thing, every day, kept small enough that you can't talk yourself out of it. Not a masterpiece. Not even good. Just done and dated. The magic is entirely in the streak -- in the unbroken chain of days, because the chain becomes something you don't want to break. Let me model the little tracker I actually keep:
// one small sketch a day. the power is the unbroken chain, not any single sketch.
function logSketch(practice, dateStr) {
const days = new Set(practice.days);
days.add(dateStr); // today is done. that's the only rule.
const streak = currentStreak([...days]);
return { ...practice, days: [...days], streak };
}
function currentStreak(days) {
const sorted = days.sort(); // ISO date strings sort correctly
let streak = 1;
for (let i = sorted.length - 1; i > 0; i--) {
const gap = dayGap(sorted[i - 1], sorted[i]);
if (gap === 1) streak++; else break;
}
return sorted.length ? streak : 0;
}
I'm not showing you dayGap -- it's just the difference in days between two dates, the boring part. The interesting part is what a streak does to your head. Once you're twelve days in, that number becomes a tiny, friendly pressure: you don't want to be the one who let the twelve become a zero. That's not discipline in the grim sense, it's momentum you built yourself and now get to lean on. And keep the daily bar embarassingly low -- ten minutes, one idea -- because a bar you can clear on your worst day is a bar that keeps the chain alive. A modest streak you actually maintain beats an ambitious plan you abandon by Thursday.
The most common thing that kills a daily practice is the blank canvas -- infinite freedom, which sounds lovely and is actually paralysing. "Make anything" is the hardest prompt in the world. The fix, which we first met way back in the seed-based and composition episodes, is to impose a constraint. Give yourself a rule to obey, and suddenly the infinite space narrows to something you can actually move around in. So I keep a little deck of constraints and draw one when I'm stuck:
// "make anything" is paralysing. a constraint turns the blank page into a playground.
const constraintDeck = [
"only circles",
"one colour plus the background",
"no more than 20 lines of code",
"it must loop seamlessly",
"black and white only",
"grid of exactly 64 cells",
"everything reacts to the mouse",
];
function drawConstraint(deck, seed) {
return deck[seed % deck.length]; // deterministic pick, reproducible per day
}
console.log(drawConstraint(constraintDeck, 3)); // -> "it must loop seamlessly"
Notice the constraint doesn't tell you what to make -- it tells you what you can't do, and paradoxically that's what frees you up. "Only circles" doesn't shrink your creativity, it focuses it, and you end up discovering ten things about circles you'd never have found with the whole toolbox open. This is the exact same power that #genuary runs on, the shared-prompt idea from last episode -- a boundary is a diving board, not a fence. When a blank day defeats you, don't reach for more freedom. Reach for a tighter rule.
Here's a sneaky truth about habits: the hardest part isn't the work, it's the starting. The five metres between "I should make something" and actually typing is where most practices die. So the smartest thing you can do isn't to build more willpower -- it's to remove the friction, to make starting almost effortless. I keep a ready-to-go starter file so I never, ever face a blank editor:
// the enemy isn't the work, it's STARTING. remove every gram of friction up front.
function todaysCanvas() {
const canvas = document.createElement("canvas");
canvas.width = 400;
canvas.height = 400;
document.body.appendChild(canvas);
const ctx = canvas.getContext("2d");
ctx.fillStyle = "#111";
ctx.fillRect(0, 0, 400, 400); // already running. just add your idea below.
return ctx;
}
const ctx = todaysCanvas(); // zero setup. the page is warm and waiting.
That little function is the whole point -- it means my daily practice begins from a warm, running canvas, exactly the "never hand a beginner a blank file" idea from the teaching episode, except now I'm being kind to myself. The idea generalises way past code: lay your tools out the night before, keep a template open, make the first step so small it's silly. When starting costs almost nothing, you start. And once you've started, momentum does the rest -- but you have to get past that first cold metre, and the way you do that is by making it warm in advance.
Now the discipline that took me the longest to learn, and honestly the most important one: finish. Not finish well -- just finish. Beginners polish one sketch forever and never post it, chasing a perfection that keeps retreating. But an ugly finished thing teaches you ten times more than a perfect unfinished one, because only finishing forces you through the boring, hard last 20 percent where the real lessons hide. So I put a hard cap on fiddling:
// perfect-and-unfinished teaches nothing. ugly-and-done teaches everything. cap the fiddling.
function shouldShipIt(sketch) {
const overTime = sketch.minutesSpent > sketch.timeBudget;
const goodEnough = sketch.tellsOneIdea; // does it say ONE thing clearly?
if (goodEnough || overTime) {
return { ship: true, note: "done beats perfect. post it, date it, move on." };
}
return { ship: false, note: "keep going, but the clock is running" };
}
console.log(shouldShipIt({ minutesSpent: 25, timeBudget: 20, tellsOneIdea: false }).ship);
// -> true (over budget -- ship it anyway)
That overTime branch is deliberately ruthless. Past your time budget, the sketch ships whether you're happy with it or not -- because the goal of a daily practice was never this one sketch, it was the hundredth one, and you only get there by clearing today's off your desk. Shipping ugly also quietly kills perfectionism, which is really just fear wearing a fancy coat. Post the flawed thing. The world does not end, someone probly even likes it, and tomorrow you get to try again a tiny bit better. Done is the engine. Perfect is the brake.
You'll notice something once you practice daily: ideas arrive at the worst possible times -- in the shower, on the tram, half-asleep -- and almost never when you're sat ready to work. If you don't catch them, they evaporate. So the second-most-useful habit after the daily sketch is keeping a seed bank: a running, messy list of half-formed ideas you can dip into on the blank days. Mine is a scrappy little thing:
// ideas come at the WORST times and vanish fast. catch every one, judge them never.
function plantSeed(bank, idea) {
return [...bank, { idea, planted: "today", grown: false }]; // no filtering. capture everything.
}
function pickSeedForToday(bank, seed) {
const unused = bank.filter((s) => !s.grown);
if (unused.length === 0) return "fresh soil today -- invent something new";
return unused[seed % unused.length].idea;
}
let bank = [];
bank = plantSeed(bank, "clock where each second is a diffrent colour");
bank = plantSeed(bank, "type that grows like moss");
console.log(pickSeedForToday(bank, 1)); // -> "type that grows like moss"
The rule that makes a seed bank work is: capture without judging. When the idea arrives, you write it down, full stop -- you do not evaluate whether it's good, because judging at capture-time scares off the shy ideas that turn out to be the best ones. Later, on a flat day when the well is dry, you open the bank and there's a month of past-you's little gifts waiting. It's the same lesson as version control from episode 136, really -- your memory is a liar, so write things down and trust the record, not your recall. A practice without a seed bank keeps reinventing the panic of the blank page. With one, you never truly start from zero.
Everybody hits the wall -- the day, or the week, where nothing comes and it all feels pointless. The beginner reads this as a verdict: "I've run out, I was never any good." That's the dangerous misread. A block is not a judgement on your talent, it's a signal with a cause, and blocks have diagnosable types. So instead of spiralling, I try to name which kind of stuck I am:
// a block isn't "you're finished". it's a signal with a cause. diagnose it, don't obey it.
function diagnoseBlock(symptoms) {
if (symptoms.everythingFeelsSame) return { type: "stale input", fix: "go look at NEW things -- not screens" };
if (symptoms.scaredItWontBeGood) return { type: "perfectionism", fix: "shrink the task til it's silly-small" };
if (symptoms.tooManyIdeas) return { type: "overwhelm", fix: "pick ONE with a constraint, drop the rest" };
if (symptoms.tired) return { type: "empty tank", fix: "rest is the work today. genuinly." };
return { type: "just starting friction", fix: "open the warm canvas and change one number" };
}
console.log(diagnoseBlock({ everythingFeelsSame: true }).fix);
// -> "go look at NEW things -- not screens"
See how each block type has a different fix? That's the whole reason naming it matters -- "stale input" and "empty tank" feel identical from the inside (flat, uninspired) but the cures are opposite: one needs new stimulus, the other needs rest. Push through an empty-tank day with brute force and you just deepen the hole; feed a stale-input day with rest and you stay bored. When I'm blocked now, my first move isn't to grind harder, it's to ask which kind of stuck is this, because the honest answer usually hands me the way out. A block is information. Read it, don't fear it.
That "empty tank" branch deserves its own section, because our whole culture gets this wrong and creative coders burn out beautifully and often. Here's what took me years to accept: rest is not the absence of practice, it's a phase of it. Your best ideas connect while you're away from the desk -- walking, sleeping, doing dishes -- when the back of your mind quietly keeps working. So a sustainable practice has a rhythm built in, and I actually model mine so I don't guilt myself for resting:
// rest isn't cheating on your practice. it's the phase where ideas connect. schedule it.
function sustainablePace(week) {
const madeStreak = week.daysMade;
const rested = week.daysRested;
const healthy = rested >= 1 && madeStreak >= 4; // most days on, at least one truly off
return {
healthy,
warning: madeStreak === 7 ? "7/7 forever is how you burn out -- take a real day off" : null,
note: "the walk where you solved it counts as work. it just doesn't look like it.",
};
}
console.log(sustainablePace({ daysMade: 6, daysRested: 1 }).healthy); // -> true
Notice the warning fires when you've worked every day -- because a seven-out-of-seven streak, forever, isn't dedication, it's a slow-motion burnout, and I've done it and paid for it. The sketch-a-day habit and a real rest day are not in conflict; the rest is what keeps the habit alive for years instead of months. This is exactly the sustainability thread we'll keep pulling on -- a practice you can only sustain in a heroic sprint isn't a practice, it's a countdown. Guard your rest as fiercely as you guard your streak. Both are the work.
One more habit that keeps a practice healthy, and it's the one everyone drops first when they get "serious": pure play. Not every session should have a point. Some of your sessions should be goalless mucking about -- no plan, no ship, no streak pressure, just following your own curiosity to see what a weird idea does. That's where the genuinely new stuff comes from, because play is the only mode where you're not trying to be good:
// not every session needs a goal. schedule pure, pointless play -- that's where novelty lives.
function playSession(curiosity) {
return {
rule: "there is no rule",
goal: null, // explicitly none. that's the point.
permission: "allowed to make something useless and delete it",
follow: curiosity.whatIfITried, // "...what if the noise controlled the SOUND instead?"
keep: "only if it surprised you",
};
}
const today = playSession({ whatIfITried: "letting a bug run wild instead of fixing it" });
That permission line is the important one -- explicit permission to make something useless. Under a streak and a portfolio and a community watching, it's easy to let every single session become performance, and performance is the enemy of discovery. So I ringfence some play: sessions I promise myself I'll never post, where the only success criterion is whether I surprised myself. Half of my favourite techniques were born in exactly those goalless afternoons, chasing a "what if" with nobody watching. Keep a corner of your practice sacred and pointless. Seriousness will eat the whole thing if you let it.
Here's the last idea, and it's the one that reframes everything above. Any single sketch is nearly worthless -- forgettable, flawed, gone by next week. But a body of them, accumulated day after day for a year, is something else entirely: it has range, it has your fingerprints all over it, and it shows a person clearly becoming themselves. You cannot see this from inside a single day. You can only see it by zooming out:
// no single sketch matters much. the BODY of work is where the magic compounds.
function bodyOfWork(sketches) {
const total = sketches.length;
const themes = new Set(sketches.map((s) => s.theme));
const bestRecent = sketches.slice(-30).some((s) => s.surprisedMe);
return {
total,
range: themes.size, // how wide have you roamed?
stillGrowing: bestRecent, // are the recent ones still surprising you?
truth: "one a day is 365 a year. nobody who does that stays a beginner.",
};
}
console.log(bodyOfWork(new Array(200).fill({ theme: "noise", surprisedMe: true })).truth);
// -> "one a day is 365 a year. nobody who does that stays a beginner."
Run the arithmetic in that last line, because it's quietly staggering: one small sketch a day is three hundred and sixty-five a year. Nobody -- and I mean nobody -- makes three hundred sketches and stays a beginner. The person who does a masterpiece-attempt once a month and abandons half of them will never, ever catch the person who quietly finishes something small every single day. That's the long game, and it's the most hopeful thing I know about this craft: you don't need talent you don't have, you need a Tuesday and the willingness to show up on it, three hundred times. The practice is the art. Everything else is just the sketches it leaves behind.
So that's the real engine under everything this series ever taught you, and you'll notice one more time how little of it was about clever code -- a streak tracker, a constraint deck, a warm canvas, a seed bank. The hard and human half is just the willingness to sit down on the flat grey Tuesday when the muse is nowhere and make one small thing anyway. Get that right and you stop being someone who did creative coding once, and become someone who does it -- quietly, daily, for years.
And here's where we go next, because there's one thing that helps enormously on the days it feels pointless: knowing you're not the first. People have been making art with machines, rules, and systems for a very long time -- long before p5.js, long before the browser, long before computers as we'd recognise them. Understanding where all of this came from, the artists and ideas we're standing on the shoulders of, changes how you see your own small daily sketches. You're a link in a long, strange, beautiful chain -- and next time we go back and walk it. 't Was plezant, and go make your one small thing today :-).
Sallukes! Thanks for reading.
X
@femdev