Build Your Talent Stack.
Be a Good Engineer
by shipping every 48 hours.
Learning by doing. Everyday. Not someday. Pick an idea Friday night. Have a working URL by Sunday. Share it & get feedback. That's the loop.
You're graduating into a different industry than 2 years before
Not worse. Different. The job you'll have in 2027 has a description that didn't exist in 2024. The good news: the people hiring you in 2027 are figuring it out at the same speed you are.
So what's actually different
The skill that mattered most when your CS curriculum was written was writing code. The skill that matters most now is shipping working systems. Those overlap, but they're not the same. AI handles a lot of the typing. It does not handle:
- Deciding what's worth building in the first place
- Knowing when the code it produced is wrong
- Wiring it into something users can actually touch
- Making it not break at 2 AM
The students who graduate ready for this don't wait for class to teach them. They build things. On weekends. For nobody. Just to learn by doing.
Your CV in 6 months will be judged by exactly two things: your GPA, and what you've shipped. One of those you've already mostly determined. The other, you can change this weekend.
Three eras in five years.
To know where to aim, look at where the puck is going. Here's the speedrun:
Era 1 — Autocomplete
Copilot suggests one line at a time. You drive every keystroke. AI is a fancy IntelliSense.
Era 2 — Pair programmer
Cursor, Claude, ChatGPT. You describe what you want; it writes the function. You read, edit, run. Conversation, not autocomplete.
Era 3 — Agents
You describe a goal. The AI plans, writes files, runs tests, fixes its own mistakes. You're the architect and the reviewer. The job is to know what good looks like.
The students who win the next two years aren't the ones who type fastest. They're the ones who can direct the system: pick the right problem, decompose it well, judge the output, and ship.
The 48-hour weekend recipe.
One project. From idea to live URL. Friday 6 PM to Sunday 6 PM. Each block is a checkpoint — if you blow past the time, scope down, don't push back.
Pick an idea (small enough to ship)
One feature. One screen. One audience. If you can't describe it in a sentence, scope down. See the idea bank if you're stuck.
Write the PRD with AI
Use the PRD prompt below. Give Claude or ChatGPT your one-sentence idea. Get back a tight one-pager. Push back on anything that feels too big — kill features.
Generate the task breakdown
Feed the PRD into the task-breakdown prompt. You should end with 8–15 numbered tasks, each shippable in under an hour. If a task is fuzzy, split it.
Build with Cursor + Claude Sonnet
Open Cursor. Drop in your .cursorrules file (template below). Work task by task. Read
every diff. Commit after each task. Sleep when tired — bad code at 3 AM is the #1 cause of death of
weekend projects.
Test it like a user
Open it in a fresh browser. Click everything. Break it on purpose. Have a friend try it. Fix the embarrassing stuff. Leave the small stuff.
Deploy to a real URL
Vercel for Next.js or static. Render or Fly for backends. Free tiers are enough. If deploy takes more than 90 minutes, your project is too complex — simplify and try again.
Tell people
One LinkedIn post. One tweet. One message to three friends. The URL, what it does, what you learned. This is the part most students skip. Don't.
You ship something imperfect on Sunday, or you ship nothing on Sunday. Those are your only two outcomes. Pick the first one.
Your weekend stack. Pick one of each. Move on.
The trap of being a final-year CS student is endless tool comparison. There are 40 AI editors. Don't compare them. Pick one. Use it for a weekend. If you hate it, switch next weekend.
The default stack (what to use this weekend)
Skip these (this weekend)
- Docker, Kubernetes, microservices — you have one user
- Custom auth from scratch — Supabase or NextAuth, done
- Tests for everything — write tests for the part most likely to break, ship
- The "perfect" framework — your first weekend project will be replaced. Pick one and move
- 15 AI tools — Cursor + Claude is enough
The prompt library.
Six prompts cover 90% of the weekend. Copy them. Edit the bracketed bits. Read what comes back — don't accept it blindly.
Idea pressure-test
Use this before you commit to a weekend on something. It saves Sunday from being a regret.
PRD generator
Turns a sentence into a one-page spec. Don't skip this — building without one is how scope eats your weekend.
Task breakdown
Feed your PRD in. Get back a checklist you can actually work through.
.cursorrules — the file that makes Cursor smarter
Put this in your repo root as .cursorrules. It's the difference between AI that
helps and AI that hallucinates.
Implementation prompt (per task)
Use this inside Cursor when starting each task. It frames the AI's response so you get diffs you can actually read.
The "explain this back to me" prompt
Use this every 3-4 tasks. The trap is shipping code you can't explain — this prevents that.
The debug prompt
When something's broken and you've stared at it for 10 minutes. The structured format is the point.
Five traps that kill weekend projects.
These are the predictable ways your Sunday ends with nothing shipped. If you know they're coming, you can dodge them.
"Build me a study app" produces 2,000 lines of nothing. "Build me one screen that takes a topic and returns 5 quiz questions" produces something you can ship. Always ask for the smallest possible end-to-end thing first.
It's tempting to accept every diff. Don't. Read every change before committing. You'll catch hallucinations, security holes, and weird patterns. More importantly: you'll learn. Skipping reading is the fastest way to ship code you can't maintain or explain in an interview.
Commit after every task. git commit -am "task 3 done" is fine. When the AI breaks something
at hour 18, git reset saves your weekend. The students who've done this before never skip
this step.
Saturday morning, the AI just shipped a working button, and you think "I should also add..." — STOP. Write the new idea on a sticky note. Keep it for next weekend. The unshipped feature is the one that kills the project.
The most common failure mode. The project is "almost done" for three weeks, then you forget about it. Deploy on Sunday, ugly bugs and all. A live broken thing teaches you 10× more than a perfect localhost. Plus, only the live version exists.
What separates a good engineer from a great one in the AI era.
AI can write the code. That used to be the hard part. Now the hard part is everything around the code — and that's the part nobody is going to teach you in a lecture. Here's what to optimize for, starting now.
Reading code > writing code
You're going to spend the next 10 years reading more code than you write. AI just made that ratio worse, in a good way. Train the muscle now: every time AI writes something, read it line by line and ask why. Not whether it works — why it's structured this way and not another way. Engineers who can't read code fast are about to have a hard decade.
Taste is your moat
When everyone has the same AI, the differentiator is judgment. Knowing which solution is cleaner. Which API is better named. Which abstraction is premature. Taste comes from one source: reading a lot of good code, and writing a lot of bad code, and noticing the gap. You build it the same way you build a body — reps, over years.
Systems thinking > syntax memorization
Memorizing the standard library mattered when looking things up was slow. It's not slow anymore. What still matters: knowing how a request travels from a browser to your database and back, where it can fail, and why your latency is 800ms instead of 80ms. That kind of thinking is invisible to AI — it has to come from you.
Ask better questions
The best engineers I know are the best at asking questions. Not just "how do I make this work" but "what am I actually trying to do" and "is there a simpler version of this problem." AI is brilliant at answering questions and useless at asking them. The job — for the rest of your career — is to be the one asking.
You used to be a code-writer. You're becoming a system-thinker who happens to write code. The weekend project is how you practice that shift before anyone's paying you to do it.
What to do Monday morning, and the Monday after that.
One weekend won't change your career. Twelve will. Here's the loop.
- Ship one thing per month. Not per weekend — per month. That gives you margin. The goal is consistency, not heroics.
- Write about each one. One LinkedIn post or blog. Not a tutorial — your honest take on what worked, what didn't, and what surprised you. This compounds faster than the projects themselves.
- Read other people's projects. Find 5 builders you respect. Read their repos and their write-ups. Steal patterns shamelessly.
- Build in public. Tweet the broken half-built version on Saturday. Post the live one on Sunday. The audience grows from the process, not the polish.
- Aim for harder problems each time. Project 1: a single API call. Project 6: a multi-user app with auth. Project 12: something a stranger pays you for. Don't repeat the same difficulty.
By the time you've shipped 6 projects, your CV stops looking like every other final-year student's. By 12, you have a portfolio that talks louder than your GPA. By 24, you don't apply for jobs — they apply to you.
Idea bank — 30 weekend-shippable projects.
Stuck on what to build? Steal one of these. They've all been built before. That's the point — building something that exists is how you learn. Originality is for project 6, not project 1.
Don't wait for the "perfect" idea. The perfect idea is the one you can ship. Pick a boring one and execute well. Originality is the easiest part of building — taste, finish, and iteration speed are the hard parts.
The talk ends. The weekend starts.
You don't need permission. You don't need another course. You don't need to wait until you "feel ready" — that feeling never arrives, and the people who shipped didn't have it either.
Pick an idea on the way home. Open Cursor when you get there. Ship by Sunday night.
That's it. That's the whole talk.