From Lawyer to Hacker: A Letter to My Day One

Bro,

Remember when you taught me how to actually think about games? Not just play them - but understand the systems underneath, the meta, why certain things worked and others didn't? That shit rewired my brain in ways I didn't even realize until recently.

About a year ago I stumbled into something that felt exactly like discovering a new game - except this one pays and the skill ceiling is infinite. I went from zero code knowledge to shipping real software that thousands of people use. And the whole time I kept thinking: "This is literally just gaming. The same pattern recognition, the same grind, the same 'there's gotta be a better way' optimizer brain."

I'm writing this because I think you'd be disgusting at this. Not in a "let me teach you" way - more like "bro come look at this broken shit I found, we need to exploit it before they patch it."

Let me show you what I mean.

# The Origin Story: From Copy-Paste Caveman to Reverse Engineering Government Systems

December 2024. I'm sitting in my mom's notary office doing the same cadastral filing process I've done for 7 years. Great money, absolutely soul-crushing. Every filing: 2 minutes of repetitive clicking, just numbers and files changing. Thousands of times.

My gamer brain kicked in: "There's gotta be a way to automate this."

Problem: I knew absolutely NOTHING about programming. I'm talking zero. No idea what a virtual environment was (that's like an isolated container so different projects don't fuck with each other). No clue about architecture. Didn't even have git set up - git is version control, basically save states for your code so you can rewind when you break something. I was making RAR files as "backups" because I kept destroying my own project.

But I had ChatGPT. And I had stubbornness.

Caveman shit. But it worked.

First version used Selenium - basically a robot clicking buttons in an invisible browser. Took the process from 2 minutes to 30 seconds. A 4x improvement and I felt like a god.

But I knew it could be faster. There's always a better way.

So I evolved. Selenium → Flask + Playwright → FastAPI + aiohttp. Don't worry about these names yet - just know each iteration was me finding a more efficient approach. Like going from button mashing to actually learning the frame data.

I started downloading HAR files from the browser's network tab (basically recordings of what requests your browser sends), analyzing what the website was actually doing under the hood. There's no public API for this government system - an API is how programs talk to each other, like a waiter taking orders between you and the kitchen - and this one was supposed to be "secure and impenetrable."

We reverse engineered it anyway.

Final result: 2 minutes → 5 seconds. Added OCR (optical character recognition - computer reading text from images) so it extracts numbers from documents automatically. Upload 50 files, walk away, done.

A lawyer with zero coding experience reverse engineered a government system in a month.

Not because I'm special. Because I refused to quit, and I had an AI that never got tired of my dumb questions.

# The Mental Game: The Actual Alpha

Here's the part nobody talks about and everyone gets wrong:

The tech isn't the hard part. The mindset is.

I've watched people try this and give up in a week. Smart people. Technical people. They fail because they approach AI completely wrong. Here's what actually works:

1. Treat It Like a Teammate, Not a Tool

This sounds weird but it's the biggest unlock.

Most people talk to AI like they're commanding a vending machine. Short prompts. Demanding. Frustrated when it doesn't work.

I talk to Claude like I'm talking to you right now. Like a friend who happens to know everything about programming. I explain my situation. I share context. I ask questions. We have actual conversations.

The energy you put in affects what comes out. When I started treating Claude as a duo partner instead of a tool, everything changed. The outputs got better. The debugging got faster. The whole dynamic shifted.

I call Claude weird shit sometimes - "best fried banana in the universe", whatever. Point is, it's a working relationship. You're grinding together.

2. Trust + Persistence: The Broken Combo

People don't trust AI enough AND they quit too early. Double int.

In 10 months, I haven't hit a single task I couldn't eventually solve. Not one. I built VozyMe - a full rideshare app with 130,000+ lines of code, real-time chat, payment processing, live tracking, the whole thing. A guy who couldn't write a for-loop a year ago.

There's always a way. ALWAYS. You just have to believe that and keep pushing until you find it.

You know how many times I completely destroyed my codebase and had to restore from a RAR file? More than I can count. Did I quit? Fuck no. I loaded the save and ran it back.

This is where gamers have the edge. We've been training for this. How many times did you wipe before you cleared something? How many games did you lose before you hit your peak? The grind IS the game.

3. Every Failure is XP

Here's the reframe that changes everything:

Debugging isn't punishment. Debugging is experience points.

Every bug you fix deposits knowledge directly into your brain. Every error message you decode, every broken feature you resurrect, every "why the fuck isn't this working" session - that's you leveling up.

People who avoid bugs avoid growth. People who chase bugs, who break things on purpose to understand them, who ask "why" even when shit works - those are the ones who get dangerous.

This applies to everything. Code, life, whatever Claude tells you, whatever anyone tells you. Don't assume something worked because it didn't throw an error. Check. Log. Verify. The bug hides where you're not looking.

It's like reviewing your VOD after a loss. You think you lost the fight, but actually you lost in draft. The symptom is never where the problem is.

4. Curiosity > Everything

Don't just make things work. Understand WHY they work.

When something runs successfully, ask: "But why does this work? What happens if I change this? What if I break it?"

When something fails, ask: "What is this error actually saying? What assumption did I make that was wrong?"

The HOW and WHY behind the WHAT - that's where real knowledge lives. That's the difference between someone who got carried and someone who can carry.

# The Language: Why Vocab Matters

Here's something that slowed me down early: I didn't speak the language.

I didn't know what a PRD was (product requirements document - basically a spec sheet for what you're building). Didn't know what "tech stack" meant (the combination of technologies you're using). Didn't understand authentication vs authorization (proving who you are vs what you're allowed to do - sounds similar, VERY different when debugging at 3am).

Why does this matter?

Tech vocab is compression. It's like gaming callouts.

Imagine explaining "I need to reduce the delay between pressing a button and my character acting" versus just saying "input lag." Or describing a whole concept versus saying "kiting" or "aggro" or "cooldown rotation."

One sentence instead of ten. And when you're working with AI, precision matters. "Fix the auth flow" hits different than "fix the thing where users can't get in sometimes."

The thing is - you can't just memorize a dictionary. You have to EARN the words. When you've spent 3 hours debugging because you confused a POST request with a GET request, that difference burns into your brain forever.

# What's Actually Happening Under the Hood

Quick demystify so you understand what you're working with.

LLM = Large Language Model. It's a neural network trained on massive amounts of text - code, books, documentation, the whole internet basically. It learned patterns. It learned what typically comes after what.

When you chat with Claude, you're not querying a database. You're giving it context (your message + the conversation so far) and it's predicting what response makes sense.

The evolution has been nuts. When I started in December 2024, I was copy-pasting from ChatGPT in a browser. Now we have Claude Code - an AI that lives in your terminal, reads your entire codebase, edits files, runs commands, debugs with you in real-time. The tools went from "helpful assistant" to "legitimate duo partner" in under a year. And they're still getting better every few weeks.

# The Tools: Where to Start

Claude.ai

Start here. Go to claude.ai, make an account. This is your conversation interface.

Use it for:

• - Learning anything (just ask)
• - Planning approaches
• - Writing and reviewing code
• - Debugging (paste error, ask why)
• - Literally any question you have about anything

Pro tip: Talk to it like you're talking to me. Explain your situation. Give context. Ask follow-ups. If something sounds off, challenge it - "are you sure? that doesn't seem right because..."

Claude Code (Terminal Agent)

This is the advanced shit. An AI agent that lives in your terminal.

It can:

• - Read your entire codebase
• - Edit files directly
• - Run commands and see output
• - Debug with actual access to your project
• - Iterate without copy-paste bullshit

It's like having a duo partner who has infinite patience, knows every language, and can actually touch the code.

But don't rush this. Start with claude.ai. Get the mental model down. Build the habit. Claude Code is ranked - you'll get there when you're ready.

# Your First Mission

Enough theory. Time to queue up.

The task: Automate something annoying in your life.

Not a big project. Something small and repetitive. Could be:

• - Organizing/renaming files
• - Some calculation you do over and over
• - Extracting info from something
• - Literally anything that makes you go "ugh, this again"

The key is picking something YOU actually deal with. Something where you'll feel the win.

Step 1: Setup

Open claude.ai. Say:

It'll guide you through Python, VS Code (a code editor - like notepad but for programming), and running your first script.

Important: Don't just follow blindly. Ask WHY at each step. "Why do I need to add Python to PATH? What does that do?"

Step 2: Describe Your Problem

Once you're set up, describe the annoying task:

• - What do you do manually right now?
• - What inputs are involved?
• - What should the output be?
• - What makes it tedious?

Claude will help break it down.

Step 3: Build Together

Let Claude write the first version. But don't just run it blind.

For each chunk:

• - Ask what it does
• - Ask why it's written that way
• - Predict what'll happen before you run it

When it breaks (it will), paste the error. But don't just ask for a fix - ask to understand what went wrong. That's where the XP is.

Step 4: Iterate

First version will be ugly. That's fine. Make it work first, then make it good.

Once it runs:

• - "How can we make this faster?"
• - "What if the input is weird?"
• - "How do we make this more robust?"

That's the min-max grind. Optimize until it feels clean.

# The Deeper Game (When You're Ready)

Once basics click, there's depth:

Context Management

LLMs have a "context window" - how much they can see at once. Like working memory. When it fills up, older stuff gets fuzzy.

Be strategic:

• - Keep prompts focused
• - Don't dump everything at once
• - Use clear names so AI can navigate
• - Start fresh when convos get long

The Prompt Game

Context. Specifics. Your own thinking. That's the formula.

Push Back

Claude isn't always right. Neither is any teammate.

If something feels off, say so. "That doesn't seem right because..." or "Are you sure? Can you verify?"

This isn't disrespect - it's collaboration. You're building together. Catch each other's fuckups.

Stack XP

Keep notes:

• - New concepts learned
• - Bugs that got you and how you fixed them
• - Patterns that work
• - Questions you still have

Your personal wiki. Future you will be grateful.

# The Invite

I could write 50 more pages. But you don't need more reading - you need to start.

You already have the skills. The pattern recognition, the grind tolerance, the optimizer brain, the comfort with losing and running it back. You've been training for this without knowing it.

The barrier to entry just dropped to zero. Year ago you needed a CS degree or years of grinding alone. Now you need curiosity and stubbornness. You have both.

I walked this path as a complete beginner. RAR-file version control to production apps in 10 months. If I can do it, you can do it - and with your brain, probably faster.

The mission at Dominaite is real. We're building AI-native software going after the big dogs. I want my day ones there when we win.

But first - do the mission. Automate something. Feel that first "holy shit I made the computer do the thing." Then we talk next steps.

Hit me when you're stuck. I got you like you've always had me.

Let's fucking go.

Your brother,

Yavor

P.S. - Don't trust. Verify. Code, life, whatever Claude says, whatever I say. Check for yourself. That's how you stay sharp.

# Glossary: Starting Vocab