I failed my first stats class in college.

Not because the math was hard. Because every example in the textbook was about iris flowers or Boston housing prices and I couldn't figure out why anyone in real life would care. So the formulas just slid off my brain.

Years later, I'm a backend dev in Mumbai with a serious filter coffee habit and an even more serious sleep deficit. One Sunday morning, somewhere between my second tumbler of decoction and a half-broken Saturday deploy, I asked myself a question I could actually feel in my body: does more coffee actually mean I write more code?

That question is what finally taught me linear regression. Not the textbook. Not the YouTube playlist. A Google Sheet, my git log, and 30 cups of filter coffee.

Here's the whole thing, including the math by hand, the part where I got it wrong, and the Python at the end.

The setup (and why I think most tutorials skip it)

Every linear regression tutorial I'd ever opened started with this line:

y = mx + b

And then immediately jumped into matrices. Cool. Useless.

The thing tutorials skip is what problem are you even trying to solve. Linear regression is, at its core, one question:

If I know X, can I make a reasonable guess at Y?

That's it. If I know the size of a flat in Malad, can I guess the rent? If I know how many standup minutes I sat through, can I guess how many I actually retained? If I know how much coffee I drank today, can I guess how many lines of code I'll commit?

I'm going to answer that last one.

The data I actually collected

For 30 weekdays I tracked two numbers:

• X: cups of filter coffee I drank that day (one tumbler = one cup, no chai counted)
• Y: lines of code I committed that day (net additions, from git log --shortstat)

Here are the first 10 rows. The full 30 are at the bottom of this post if you want to play with them yourself.

Before doing any math, Before doing any math, I dropped the numbers into a scatter plot maker and just sat with it for a minute. You should always do this first. Eyeballs are a free regression model.
and just looked at it. You should always do this first. Eyeballs are a free regression model.

What I saw: a clear-ish upward smear. Not a perfect line — day 5 (5 coffees → 305 lines) and day 10 (6 coffees → 360 lines) sit a bit off the trend, and day 7 (zero coffee, 40 lines) was the day there was a 4-hour power cut and I worked off my laptop battery in a café. But overall, more coffee, more code.

That smear is what linear regression turns into a number.

What we're actually trying to find

We want to draw the single straight line that fits this cloud of points as well as possible.

A line has two parts:

• Slope (m): how many lines of code does one extra cup of coffee buy me?
• Intercept (b): how many lines of code do I write on a day with zero coffee?

If I find good values for m and b, then for any future day, I can plug in my coffee count and get a prediction.

But "fits as well as possible" — what does that mean? This is the bit that took me embarrassingly long to internalize.

The "least squares" idea, explained without the squares

Imagine I draw a random line through the cloud. For each real data point, there's a gap between where the point actually is and where my line thinks it should be. That gap is called the residual — basically, how wrong the line was for that day.

If I add up all those gaps, I get a "total wrongness" score. The best line is the one with the smallest score.

One catch: some gaps are positive (line predicted too low), some are negative (predicted too high). If you just add them, they cancel each other out and you get a line that looks correct on paper but is actually terrible.

The fix is to square each gap before adding them. Negatives become positives, big mistakes get punished more than small ones, and now you have a real "wrongness" number worth minimizing.

That's why it's called least squares regression. We're picking the line that makes the sum of squared gaps as small as possible.

That's the whole intuition. The formulas below are just the calculus result of "find the m and b that minimize that sum."

Doing it by hand on 5 data points

Let me use just 5 points so the numbers stay sane:

Step 1: averages.

• Mean of X: (2+4+1+3+5)/5 = 3
• Mean of Y: (142+287+95+210+305)/5 = 207.8

Step 2: deviations and products.

For each row I compute (X - meanX), (Y - meanY), their product, and (X - meanX)².

Sums: products = 565.0, squared deviations = 10.

Step 3: slope.

m = sum of products / sum of squared deviations
m = 565 / 10
m = 56.5

Step 4: intercept.

b = meanY - m * meanX
b = 207.8 - 56.5 * 3
b = 207.8 - 169.5
b = 38.3

So my fitted line is:

lines_of_code ≈ 56.5 * coffees + 38.3

Read in English: every extra cup of coffee buys me ~56 more lines of code, and on a zero-coffee day I'd still grind out about 38 lines. That intercept matches my power-cut day pretty well (40 lines).

I checked this against an online linear regression calculator and got the same numbers, which was nice — I'd been low-key worried I'd dropped a sign somewhere. (When you're learning this, do the by-hand version and then verify with a tool. Two methods agreeing is how you know you actually understand it, not just memorized it.)

The mistake I made the first time

When I ran this on all 30 days, I got a slope of about 53 and an intercept of about 42. Close enough.

But then I made a prediction:

"If I drink 15 cups of coffee, I'll write 53 × 15 + 42 = 837 lines of code."

This is wrong, and it's wrong in a way that's worth understanding. My data only ranged from 0 to 6 cups of coffee. Predicting for 15 cups is called extrapolation, and a linear model has no idea that at 15 cups I would actually be in the ER, not in VS Code.

The relationship is probably linear-ish in the range I measured. Outside that range, all bets are off. Most real-world relationships curve, plateau, or break at some point. Linear regression is a local approximation, not a universal law.

This is the most common mistake I see beginners make, and honestly it's the most common mistake I see in production dashboards too. "Our user growth was linear for six months, so we'll hit ten lakh users by Q4." No you won't.

How good is my line, actually?

A line that's "best" can still be terrible. Imagine if my data were a random cloud — there'd still be a best line, but it would predict nothing useful.

The standard score for this is R² (pronounced "R squared"). It's a number between 0 and 1:

• R² = 1: the line passes through every point. Perfect.
• R² = 0: the line is no better than just guessing the average.
• R² = 0.7: the line explains about 70% of the variation in Y.

For my 30-day coffee experiment, R² came out to about 0.89. That's strong — coffee really does seem to track my coding output. But correlation isn't causation, and here's where I have to be honest: on high-coffee days I was probably also more rested, more motivated, and not stuck in a 90-minute Outer Ring Road jam. The coffee might be a side effect of a productive day, not the cause of one.

Linear regression will happily fit a line. It will not tell you what causes what. That's your job.

The Python version (5 lines)

Once you understand what's happening, the code is almost a letdown:

import numpy as np

x = np.array([2, 4, 1, 3, 5, 2, 0, 4, 3, 6])
y = np.array([142, 287, 95, 210, 305, 160, 40, 250, 195, 360])

slope, intercept = np.polyfit(x, y, 1)
print(f"y = {slope:.1f}x + {intercept:.1f}")

If you want R² and the rest of the diagnostics, scipy.stats.linregress is the friendlier version:

from scipy.stats import linregress

result = linregress(x, y)
print(f"slope: {result.slope:.2f}")
print(f"intercept: {result.intercept:.2f}")
print(f"r-squared: {result.rvalue**2:.3f}")
print(f"p-value: {result.pvalue:.4f}")

The p-value is asking: "what's the chance this slope is just noise?" Anything under 0.05 is the traditional cutoff for "probably real." Mine came in at 1e-14, which means: almost certainly not a coincidence. (Doesn't mean coffee causes code. Just means the relationship is real, whatever it is.)

When to reach for linear regression in real life

Honestly, more often than you'd think. Some boring-but-genuinely-useful examples from my own work:

• Estimating ticket resolution time from ticket length. Helps with sprint planning.
• Predicting cloud bill from monthly active users. Helps when pricing a new tier — and trust me, the finance team will ask.
• Figuring out at what page-load speed users start churning on a landing page. The slope tells you how many sign-ups each extra 100ms costs.
• Calibrating a sensor. If your IoT temperature reading drifts linearly off a reference thermometer, regression gives you the correction formula in two lines of Python.

The pattern is always the same: you have an X you can measure cheaply, and a Y you actually care about, and you want a quick "if I move the dial on X by this much, what happens to Y?"

It is not magic. It is a ruler. But it's a ruler that knows about uncertainty, which is more than most rulers can claim.

What to try this week

If you want this to actually stick, don't just read it. Pick something annoying in your life that has two numbers attached to it, and track it for two weeks.

Some ideas to steal:

• Hours of sleep vs. time-to-first-coffee (or chai) the next morning
• Number of standup attendees vs. how long it actually ran
• PRs opened that day vs. PRs you reviewed
• Daily commute minutes vs. how cranky you felt at the 6 PM standup

Plug it into any regression tool (I obviously used this one), look at the slope, and ask: does this number match my gut? If yes, you've quantified your intuition. If no, you've found something interesting.

That's the whole point of stats, when you strip away the textbook flavor. It's a tool for arguing with your own assumptions.

The full dataset

If you want to reproduce what I got, here's all 30 days:

coffees = [2,4,1,3,5,2,0,4,3,6,2,3,4,1,5,3,2,4,5,1,3,4,2,6,3,4,2,5,3,4]
lines   = [142,287,95,210,305,160,40,250,195,360,170,225,260,80,330,
           205,150,265,310,90,200,255,165,355,200,270,155,315,210,275]

Drop those into the snippet above. You should get a slope around 53, intercept around 42, R² around 0.89.

And then go track something of your own. That's when it actually clicks.

If you spot a math mistake, please yell at me in the comments. I'd rather be embarrassed than wrong.