Spoiler: I by chance overfitted to Monday standup and obtained caught in an area minimal of Slack notifications.
We speak rather a lot about AI at work — instruments, automation, LLMs changing interns. However what if I flipped it: what occurs if I attempt to work like a machine studying mannequin?
For per week, I approached my 9-to-5 via the lens of ML paradigms: supervised studying, reinforcement studying, overfitting, and so forth. It was half productiveness experiment, half satire, half cry for assist.
The premise was easy: I wouldn’t make choices. I’d solely act primarily based on labeled enter. Like a mannequin skilled on a clear dataset, I adopted specific directions, nothing extra.
Instance:
def respond_to_ticket(ticket):
if ticket["label"] == "bug":
fix_bug(ticket["module"])
elif ticket["label"] == "characteristic":
build_feature(ticket["description"])
else:
return "Can not classify."
Duties grew to become binary. No exploration, no technique — simply excessive accuracy on predefined labels. It felt environment friendly at first. Till I spotted…
- I ended asking “why are we doing this?”
- I waited for labels as a substitute of initiating something
Verdict: Nice for junior engineers. Terrible for individuals who wish to really feel alive.
I assigned reward values to duties. Code merged = +1. Espresso = +0.5. Ending work earlier than 6PM = +3. I even tried tuning a “coverage.”
Instance reward loop:
reward = 0
if pr_merged:
reward += 1
if no_meeting_missed:
reward += 0.5
if finished_before_6:
reward += 3
What occurred subsequent?
- I obtained hooked on fast wins (small PRs > large tasks)
- I gamified my time monitoring (Toggl grew to become my reward sign)
- I found I’d reasonably refactor a linter than write documentation
Ultimately, I used to be optimizing for the reward perform, not for precise worth. I used to be… productiveness overfitting.
At this level, I spotted I used to be too good at sure patterns. Standup at 10:00 → Code until lunch → Panic about progress → False sense of management through calendar blocking.
It felt like I had skilled a private mannequin on a slim dataset of “how I work” — and any deviation broke the system.
Signs of overfitting:
- Autocompleting Slack replies with out studying the message
- Writing the identical utility perform 3 times in numerous providers
- Treating code assessment like regex matching: search for syntax, ignore semantics
Coding analogy:
def process_input(input_data):
if input_data in training_data:
return memorized_output[input_data]
else:
return "404: Generalization Error"
In some unspecified time in the future, I wrote three practically an identical capabilities for formatting dates in numerous microservices. The mannequin (me) had memorized the answer — and didn’t summary it.
At 10:03 AM I obtained an e-mail from an exec:
“Hey, can you’re taking a fast take a look at this deck?”
No topic. No context. Simply vibes.
It was an adversarial pattern. My mind froze like a mannequin uncovered to a stickered cease signal.
Crash traceback:
UnexpectedInputException: 'fast take a look at this' shouldn't be a acknowledged instruction.
Did you imply: ‘do 6 hours of labor last-minute’?
My “mannequin” began hallucinating worst-case outcomes:
- “That is about layoffs.”
- “They discovered my medium put up.”
- “I’m going to have to write down bullet factors in a Google Slides deck.”
Word: Adversarial robustness shouldn’t be a solved downside in people both.
By Friday I attempted making use of classes from earlier within the week to new issues — reviewing a teammate’s Python pipeline though I normally write TypeScript.
And it kinda labored! I introduced patterns from my code to theirs — DRY rules, testing conventions, even mild variable title bullying.
Switch studying IRL:
# Unique area
def get_user_data(id: str) -> dict:
# Basic, boring stuff
move
# New area
def fetch_customer_profile(uid: str) -> dict:
# Identical idea, new context
move
I didn’t want to start out from scratch — I reused weights from my “supply area” (frontend dev) and fine-tuned them for the brand new process.
