Author: Masaru @ The Engineering Dad

Project: The Stress-Sensing Architectural Interface

Target Archetype: The Orchestrator (Architectural Engineering + Applied Psychology)

Let’s introduce another example for those interested Engineering and Psychology which appear to be fairly popular among students. Here’s how I would approach for the upcoming summer.

Part 1: The Strategic Audit (The “Why”)

The “Maker Portfolio” is the physical evidence that a student is not just a Processor (someone who follows a syllabus) but an Orchestrator (someone who identifies a Problem Space and builds a technical solution). For a T20 applicant, a 4.0 GPA and a 1550 SAT are just the Binary Check to get in the door. The Portfolio is the Signal that actually gets them admitted.

“Admissions readers don’t care about titles. They care about what you built. The distinction between a consumer and a builder isn’t grades or prestige, it’s whether you’ve ever shipped something real.”

— Masaru, from [Builder Delta Framework: Why Club President Titles Don’t Matter]

The Current Project “State”

Right now, an “Emotion/Stress Sensing App” risks looking like a “hobby app” or a “Software-only” project. In the 2026 landscape, AI-generated software is a commodity. To stand out, we need to build a Physical Strength.

The Targeted “Spike”

We are positioning your child at the intersection of Human-Centric Design and Hardware Engineering. This shows s/he understands how the physical world (architecture) impacts the internal state (psychology), and how technology (sensors) can bridge that gap.

Part 2: The Project Blueprint (The “How”)

To execute the Orchestrator vision, the project must move through three distinct technical layers:

Layer 1: The Physical Strength (Hardware)

Instead of relying on user input (which is subjective), we integrate hardware to collect objective data.

• The Tech: A Raspberry Pi or Arduino-based wearable.

• The Sensors: Galvanic Skin Response (GSR) for sweat levels or a Pulse Oximeter for heart rate variability (HRV).

• The Signal: This proves she can handle “Physical-to-Digital” architecture—a core requirement for Tier-1 engineering programs.

Layer 2: The Data Audit (The “Log Files of Failure”)

T20 admissions officers at schools like MIT value the process more than the product.

• The Requirement: S/he must maintain a “Development Log.”

• The Content: Documentation of every failed algorithm, every sensor miscalibration, and every logic error. This is the Audit Trail. It proves s/he has “Technical Skin in the Game.”

“A public trail of your building process is more valuable to an admissions officer or recruiter than a polished final product. Why? Because it shows problem-solving in action, not just problem-solved.”

— Masaru, from [Pre-Summer Action Plan: From Consumer Trap to Builder in 8 Weeks]

Layer 3: The Interdisciplinary Spike (Psychology)

To elevate this from a “gadget” to a “Research Project,” s/he must cite the “Source Code” of human behavior.

• The Framework: Integrating Cognitive Behavioral Therapy (CBT) principles into the app’s “Calming Suggestions.”

• The Outcome: This turns her into a Translator—someone who can speak the language of both the Engineer and the Psychologist.

Part 3: Required Template Items (Data Collection)

To complete this Audit Trail for the digital portfolio, she needs to collect the following “Receipts” as she builds:

• Problem Space Definition: A 1-page write-up on why “Environmental Stress” is a systemic architectural failure.

• Hardware BOM (Bill of Materials): A technical list of every sensor, microcontroller, and wire used.

• The “Failure Matrix”: A spreadsheet of at least 10 major technical bugs she encountered and the “Patch” she engineered to fix them.

• Logic Flowcharts: Visual diagrams showing how sensor data (Input) leads to calming suggestions (Output).

• The “User Research” Log: Qualitative data from testing the prototype on 5–10 people to prove the “System Efficacy.”

“Building for someone else introduces real-world constraints that a classroom never can. Simple + shipped is better than complex + never finished.”

— Masaru, from [Pre-Summer Action Plan: From Consumer Trap to Builder in 8 Weeks]

The “Exit Velocity” Goal

By the time she interviews with a Cornell or Stanford alum, s/he won’t be talking about grades. S/he will be opening a tablet to show:

• A video of a working hardware prototype

• The schematics behind it

• The psychological data that justifies its existence

• The failure log that proves she debugged it herself

That is how you win.

Next: The Broader Context

If you want to understand how this fits into the bigger picture of CS college admissions, read:

• “From Science Fair to Salary: How to Turn High School Research into a Paid College Internship” — How to productize and monetize your projects

• “The Formal Program Trap: Why your 9th grader should build a lab, not join one” — Why independence beats institutional programs

• “Why ‘Looking for an Internship’ is the Worst Way to Find One” — How builders get recruited vs. how consumers apply

Ready to get more building started? My High School CS Toolkit includes:

• The 4-Year Orchestrator roadmap (what to build each year)

• 12 project archetypes (problems worth solving)

• The “Build in Public” playbook (how to document your journey)

• Real case studies from my own kids’ summer projects

The toolkit removes the guesswork. All you have to do is pick a problem and build.

Drop a comment and let me know what you are building.

Support the Workshop: I spend my spare cycles auditing the “Source Code” of admissions so you don’t have to. If you’ve found value in these logic gates, you can buy me a coffee ☕ to help keep this workshop running and the guides open-source.

Support the Workshop

Author: Masaru @ The Engineering Dad

The Reality Check

Top-tier engineering and Computer Science schools (like MIT, CMU, Cornell, or Berkeley) do not look at applicants the same way liberal arts programs do. They don’t care if you are a “well-rounded” student with a dozen superficial clubs.

They want academic rigor and specialized focus. They want to know one thing: Can this student handle intense, highly abstract quantitative coursework without breaking?

If you want your student to even be considered at the starting line of elite CS admissions, their high school course matrix needs to look like a pre-engineering curriculum. Here is the roadmap.

Mathematics: The Ultimate Filter

Let’s correct a massive misconception: Computer Science is not just coding; it is applied mathematics. Admissions committees look at your math trajectory first. If you aren’t pushing the boundaries of what your school offers, you are out.

The Target: AP Calculus BC is the bare minimum requirement for senior year. Ideally, they reach this by junior year.

The Ideal Trajectory:

• 9th Grade: Honors Geometry / Honors Algebra 2

• 10th Grade: Honors Pre-Calculus

• 11th Grade: AP Calculus BC (Take the AP exam and aim for a 5)

• 12th Grade: Multivariable Calculus, Linear Algebra, or Discrete Math (via dual enrollment at a local community college or online university program).

Why it matters: Discrete Math and Linear Algebra are the literal bedrock of machine learning, graphics, and cryptography. Showing competency here as a high schooler sets an applicant miles ahead.

“The degree is a chain, not a bucket. If you don’t have Calculus I, you can’t take Physics. If you don’t have Physics, you can’t take the upper-division Engineering core. You can enter a university with enough credits to be a ‘Junior’ by status, but if you haven’t cleared the specific math and science sequences, you are effectively a Freshman in your major.”

— Masaru, from [The Prerequisite Bottleneck: Why 90+ College Credits Won’t Save You 4 Years of Tuition]

Some parents ask what about AP stats? In many engineering programs, math stat requirements vary as well as in some cases, it is a junior (300 level) course. In this case, AP stat doesn’t transfer as math requirement class (thus becoming just an elective transfer credit), so the better path to reduce math requirements is to go with Multivariable Calculus.

Science: Rigor Over Breadth

Do not let your student take “soft” science options to protect their GPA. Elite CS programs require deep, calculus-based scientific foundational knowledge.

The Target: AP Physics C (Mechanics and Electricity & Magnetism) and AP Chemistry.

The Strategy:

• Skip generic “Physical Science” tracks. Move straight into Honors Biology/Chemistry in 9th and 10th.

• By 11th or 12th grade, they must take AP Physics C. Why? Because it uses calculus to solve physical problems. It proves to the admissions office that their math skills aren’t just theoretical, they can apply them.

Computer Science: Go Beyond the High School Curriculum

Taking AP Computer Science A is necessary, but it is a baseline, not a differentiator. AP CS A teaches basic Java loops and arrays, it’s a freshman-level introductory course at best.

The Strategy:

• Take AP CS A early (10th or 11th grade): Get the 5 on the exam to clear the high school prerequisite.

• The Self-Directed Pivot: Once the school curriculum ends, the real work begins. The student must transition into independent, project-based engineering. This means building real tools, managing version control on GitHub, or competing in high-level youth robotics (FTC/FRC) where they write actual autonomous routines, not just classroom scripts.

The “Builder” Differentiator

Every perfect-GPA student applying to top CS schools has taken Calculus and Physics. To stand out, your coursework must connect directly to tangible execution.

“What will they build this summer that makes programs irrelevant? Simple + shipped is better than complex + never finished. Admissions officers know this. A Builder project always starts with a problem, not a textbook.”

— Masaru, from [Pre-Summer Action Plan: From Consumer Trap to Builder in 8 Weeks]

The Rule of Execution: If a student takes a high-level class, they must immediately apply that knowledge to a personal project outside school.

• Took AP Stats? Use it to analyze a data set on a topic they care about.

• Took AP CS A? Use that Java knowledge to build a mod, an app, or an automation script.

• Took AP Physics C? Apply it to a robotics project, a simulation, or a physics engine.

“The distinction between a consumer and a builder isn’t grades or prestige, it’s whether you’ve ever shipped something real that improves someone else’s life. Admissions readers don’t care about titles. They care about what you built.”

— Masaru, from [Builder Delta Framework: Why Club President Titles Don’t Matter]

The Learning Loop: From Idea to Execution

The gap between having an idea and seeing it work on screen is where real learning happens.

“It’s never syntax. It’s never logic. It’s the gap between having an idea and seeing something work on the screen. That gap kills momentum faster than any hard concept does. Debugging the AI is where the actual learning truly happens.”

— Masaru, from [The $0 Vibe Coding Stack]

The goal isn’t just to get accepted, it’s to graduate with your technical velocity intact.

The Bottom Line

Build a rigorous, math-heavy foundation. Prove they can handle the hardest technical tracks available. And use that knowledge to build real things, things that solve problems, that other people use, that create a moat.

That is how you get in.

The Opportunity Window

If your student is in the “still figuring it out” camp, that’s exactly where the opportunity is. The 8.1% enrollment drop means the gatekeepers are hungry for students with genuine builder mentality. You have a two-year window to shift from generic CS to applied engineering.

Start now.

Masaru
The Engineering Dad

P.S. If your student is in the “still figuring it out” camp, that’s exactly where the opportunity is. The 8.1% enrollment drop means the gatekeepers are hungry for students with genuine builder mentality. You have a two-year window to shift from generic CS to applied engineering. Start now.

Next: The Broader Context

If you want to understand how this fits into the bigger picture of CS college admissions, read:

• “From Science Fair to Salary: How to Turn High School Research into a Paid College Internship” — How to productize and monetize your projects

• “The Formal Program Trap: Why your 9th grader should build a lab, not join one” — Why independence beats institutional programs

• “Why ‘Looking for an Internship’ is the Worst Way to Find One” — How builders get recruited vs. how consumers apply

Ready to get more building started? My High School CS Toolkit includes:

• The 4-Year Orchestrator roadmap (what to build each year)

• 12 project archetypes (problems worth solving)

• The “Build in Public” playbook (how to document your journey)

• Real case studies from my own kids’ summer projects

The toolkit removes the guesswork. All you have to do is pick a problem and build.

Drop a comment and let me know what you are building.

Support the Workshop: I spend my spare cycles auditing the “Source Code” of admissions so you don’t have to. If you’ve found value in these logic gates, you can buy me a coffee ☕ to help keep this workshop running and the guides open-source.

Support the Workshop

Author: Masaru @ The Engineering Dad

Most Computer Science students think getting a job senior year starts in senior year.

It doesn’t.

By the time you walk into your senior fall, the game is already 90% over.

The market doesn’t care about your degree; it cares about your proof of production. If you want a guaranteed return offer sitting in your inbox before your senior spring even begins, you need a tactical, four-year compounding strategy.

Here is your year-by-year execution blueprint.

Freshman Year: Transition from Consumer to Builder

Your goal this year isn’t a FAANG internship, it’s building a baseline of credibility so recruiters don’t instantly bin your resume next year.

The Focus: Fundamentals and proof of execution.

The Strategy:

Master Data Structures & Algorithms (DSA) early: Do not wait for your university class to teach this. Start self-studying on LeetCode or HackerRank by second semester. Target 1–2 easy/medium problems a day.

Build one “Anchor Project”: Stop doing generic classroom assignments. Build a functional, open-source project, a web scraper, a local automation tool, or a basic hardware/software integration. Put the code on GitHub.

The Summer Move: If you can’t land a formal freshman internship (like Microsoft New Tech or Google STEP), do not waste the summer. Work a local IT job, contribute to open source, or build a complex project.

Sophomore Year: The Local & Boutique Grind

This is the bridge year. You are hunting for real-world experience, even if it’s at a 10-person local company or a university research lab.

The Focus: Getting a real tech company name on your resume.

The Strategy:

Target Mid-Tier & Local Companies: Everyone fights for 100 FAANG slots. Apply to local engineering firms, defense contractors, or regional banks. A line on your resume that says “Software Engineering Intern” at a no-name company is worth 10x more than an empty summer.

If you left the organization tomorrow, what system would break? If the answer is ‘nothing,’ you haven’t built a moat yet.

— Masaru, from [The Builder Delta: Why Club President Matters More Than AP Scores]

The Interview Prep: Ramp up to LeetCode Mediums. Focus on strings, arrays, linked lists, and trees.

Network Inbound: Attend local tech meetups or university career fairs not just to hand out resumes, but to ask engineering leads what problems they are solving.

Junior Year: The Main Event

This is the most critical professional year of your college career. The internship you land this summer is your direct pipeline to a full-time job.

The Focus: High-tier internship acquisition.

The Strategy:

The August Blitz: The hiring season for Junior summer begins one full year in advance. Your resume must be polished and ready by August. Apply to 100+ positions within the first 6 weeks of the semester.

If your value prop is “I write code fast,” you’re competing with a machine that does it for $0.01 a minute. What stands out is architecture thinking, system optimization, and using AI as a force multiplier.

— Masaru, from [The CS Major Isn’t Dead—It’s Just Filtering for Builders]

Systematic Interviewing: Treat interviewing like a 3-credit course. Dedicate 10 hours a week to system design basics, behavioral preparation (STAR method), and mock interviews.

The Target: Secure a role at a company with a high return-offer rate (historically 70-80%+ for well-performing interns).

Senior Year: Closing the Deal

The internship is secured. Now you have to convert it from a 10-week trial into a career.

The Focus: The Return Offer.

The Strategy:

Own Your Scope: On day one, ask your manager: “What does a successful internship look like, and what metrics define a return-offer candidate?”

Over-Communicate: Don’t sit in a corner trying to look smart. Ask sharp questions, document your code meticulously, and give clear daily updates.

No one photographs the joist alignment. But the measurable change, the delta, lives in what’s hidden. The infrastructure no one sees is what determines whether the system survives.

— Masaru, from [Building Culture: Why I Spent More on My Kids’ Projects Than Their Tuition]

Deliver the MVP Early: Focus on getting a working, baseline version of your summer project running by week 6. Spend the remaining weeks optimizing, testing, and integrating it.

The Bottom Line

When you ship clean code, integrate seamlessly with the team, and demonstrate a builder mindset, the company will lock you in before senior spring. You get to coast through graduation while everyone else is scrambling.

This isn’t luck. It’s a four-year compounding strategy starting freshman year. Freshman → Sophomore → Junior → Senior. Each phase builds on the last. By the time you walk into senior fall, the 90% is already decided.

The market is filtering for builders. Start building now.

Next: The Broader Context

If you want to understand how this fits into the bigger picture of CS college admissions, read:

• “From Science Fair to Salary: How to Turn High School Research into a Paid College Internship” — How to productize and monetize your projects

• “The Formal Program Trap: Why your 9th grader should build a lab, not join one” — Why independence beats institutional programs

• “Why ‘Looking for an Internship’ is the Worst Way to Find One” — How builders get recruited vs. how consumers apply

Ready to get more building started? My High School CS Toolkit includes:

• The 4-Year Orchestrator roadmap (what to build each year)

• 12 project archetypes (problems worth solving)

• The “Build in Public” playbook (how to document your journey)

• Real case studies from my own kids’ summer projects

The toolkit removes the guesswork. All you have to do is pick a problem and build.

Drop a comment and let me know what you are building.

Support the Workshop: I spend my spare cycles auditing the “Source Code” of admissions so you don’t have to. If you’ve found value in these logic gates, you can buy me a coffee ☕ to help keep this workshop running and the guides open-source.

Support the Workshop

Author: Masaru @ The Engineering Dad

If you ask any modern AI model to “create a roadmap for a high schooler to get into a top-tier Computer Science program,” it will spit out a flawless, beautifully formatted 8-step bulleted list in about four seconds.

It will tell them to learn Python, build a GitHub portfolio, and join a robotics team.

The information is free. It’s accurate. And it is completely useless on its own.

We have officially entered an era where answers are a commodity. If your child’s entire competitive edge relies on knowing what the standard path looks like, they are already behind. AI knows the path perfectly.

The crisis facing the next generation isn’t a lack of information; it’s a paralyzing lack of execution.

Consumers follow scripts. They check checkboxes. They master existing syllabi, all replaceable skills in the AI era. Builders identify unstructured failures in the wild, design frameworks, and orchestrate real-world systems.

— Masaru, from [The Syllabus Consumer Trap: How to Identify Real Problems]

The Consumer vs. The Builder

Over my career as an industry researcher, tech program manager, and robotics coach, I’ve watched the line between two types of students sharpen into a razor-blade:

The Consumers: They collect credentials. They prompt the AI. They ask for the syllabus. They look for the spoon-fed answer key. When the script throws an unexpected error, they freeze or ask a forum to fix it for them.

The Builders: They look at a broken system, a broken piece of code, or a pile of aluminum parts, and they start iterating. They don’t wait for permission or a perfect curriculum. They have skin in the game.

The builders I’ve coached don’t wait for permission or a perfect curriculum. They identify a broken system and start iterating immediately. That’s the differentiator that colleges see and that tech companies hire for.

— Masaru, from [The Pre-Summer Action Plan: From Consumer Trap to Builder in 8 Weeks]

When AI can generate an entire application stack or write standard boilerplate code instantly, the market value of a pure “Consumer” drops to zero.

Your kid doesn’t need more information. They need to learn how to build through frustration.

My Three Rules for Cutting Through the Noise

As a father who has guided three kids through the gauntlet of engineering degrees into successful tech careers, and coached youth robotics teams from FLL up to world-level FRC competitions, I don’t care about theoretical paths. I care about what works when the pressure is on.

If you want your kids to stay a step or two ahead of the curve, stop giving them answers. Give them constraints.

The true differentiator isn’t what you know, it’s what you’ve shipped under real constraints. The Impact Delta is where the market actually values your work: Δ (Impact) = f(Systemic Orchestration) - f(Standard Manual Consumption).

— Masaru, from [The Builder Delta: Why Club President Matters More Than AP Scores]

Demand Data and Execution over Emotion: When a project fails or a college application doesn’t go their way, don’t let them wallow in the “why me.” Break the failure down like a post-mortem engineering report. What are the 3 micro-tasks we can execute tomorrow morning to iterate? Treat life like an agile sprint.

Enforce Strict Meritocracy: The fastest way to cripple a young engineer’s career is to do the heavy lifting for them. If my kids or my robotics students wanted an internship or a solution to a complex mechanical problem, I never handed it to them. I provided the toolkits, the frameworks, and the strategic guardrails. The actual miles? They had to walk them.

Meritocracy isn’t about participation trophies. It’s about real skin in the game. When you build something that solves an actual problem, not for a grade, but because the system is broken, that’s when you develop the resilience and systems thinking that separates builders from consumers.

— Masaru, from [Building Culture: Why I Spent More on My Kids’ Projects Than Their Tuition]

Look for “Proof of Work” Projects: Anyone can put “proficient in Python” on a resume. Nobody believes it anymore. What stands out is a project with dirt under its fingernails, a local AI infrastructure built on an old office server, a custom-tuned agentic workflow that solves a real business problem, or a fully functioning robot built under tight budget constraints.

The Shift

If you are reading newsletters, buying courses, or looking for guides that simply give you “facts you can find on Google,” you are wasting your time and money.

The true currency of the AI era is High-Trust Execution.

The CS major isn’t dead. It’s just filtering for builders. Students who can identify real problems, ship solutions under constraints, and measure impact are emerging as the new tier-1 credential. Credentials alone won’t cut it, only proof of orchestration.

— Masaru, from [The CS Major Isn’t Dead—It’s Just Filtering for Builders]

In this publication, I’m not here to summarize tech trends or give you abstract parenting theories you could generate yourself with a prompt. I’m going to share the exact, granular, battle-tested playbooks I’ve used to build a high-performing digital and technical ecosystem within my own family and teams.

We don’t just talk about the tech stack; we build it.

Get your hands dirty. Teach your kids to do the same.

Let’s build.

If you’re ready to move your kids from consumers to builders, keep an eye out for our upcoming College Internship Playbook, currently being beta-tested by real-world students who are actively executing the strategy.

Next: The Broader Context

If you want to understand how this fits into the bigger picture of CS college admissions, read:

• “From Science Fair to Salary: How to Turn High School Research into a Paid College Internship” — How to productize and monetize your projects

• “The Formal Program Trap: Why your 9th grader should build a lab, not join one” — Why independence beats institutional programs

• “Why ‘Looking for an Internship’ is the Worst Way to Find One” — How builders get recruited vs. how consumers apply

Ready to get more building started? My High School CS Toolkit includes:

• The 4-Year Orchestrator roadmap (what to build each year)

• 12 project archetypes (problems worth solving)

• The “Build in Public” playbook (how to document your journey)

• Real case studies from my own kids’ summer projects

The toolkit removes the guesswork. All you have to do is pick a problem and build.

Drop a comment and let me know what you are building.

Support the Workshop: I spend my spare cycles auditing the “Source Code” of admissions so you don’t have to. If you’ve found value in these logic gates, you can buy me a coffee ☕ to help keep this workshop running and the guides open-source.

Support the Workshop

Author: Masaru @ The Engineering Dad

Here is why the “Post-Pure-CS” era is the best thing to happen to top-tier applicants and true innovators.

For the past decade, a Computer Science degree was treated like a golden ticket. It was a cultural consensus: get the degree, land a mid-six-figure job straight out of college, and enjoy a comfortable coast.

Now, the tech industry is shifting, and panic has officially set in.

Recent data from the National Student Clearinghouse reveals a stark correction: undergraduate enrollment in computer science programs at four-year institutions dropped 8.1%, the steepest one-year decline of any major since at least 2020. Graduate enrollment plunged even deeper, down 14%. Simultaneously, Nobel Prize-winning economists and major media outlets are declaring that the “CS bubble is bursting” and that AI has “wiped out” coding as a reliable career path.

If you are a parent or a student navigating the college admissions landscape right now, this looks terrifying, right?

But if you look at this data through the lens of history, it isn’t a tragedy. It’s a massive competitive advantage. For those of us who have spent decades in tech, engineering, and academia, this trend doesn’t mean technology is dying. It means the market is finally filtering out the noise.

The Death of the “Syntax Monkey”

Let’s be blunt: the era of the “bootcamp-and-chill” coder is over. The days when you could copy-paste basic JavaScript, cruise through a mediocre CS program without building anything original, and land a massive salary are gone.

AI has fundamentally changed the nature of software development. It can write boilerplate syntax, debug standard code blocks, and automate routine technical tasks in seconds. If a student’s entire value proposition is simply knowing how to write syntax, they are competing with a machine that works for pennies.

But writing syntax was never what made a great engineer.

As I’ve written about the “Builder vs. Consumer Framework”: “If you left the organization tomorrow, what system would break? If the answer is ‘nothing,’ you haven’t built a moat yet.” A syntax monkey has zero strength. An architect has everything.

My three children are all successful software engineers, including one who graduated from Cornell, and another who chose to attend Rice instead of Caltech/Columbia acceptances.

Do you know why they aren’t panicking about these headlines?

Because they aren’t syntax monkeys.

They are builders.

They understand architecture, system optimization, hardware-software integration, and how to use AI as a force multiplier to ship products ten times faster than the generation before them.

Where the Momentum is Actually Shifting

When pure CS enrollment drops, the crowd assumes tech is dead.

They run away.

But as a former robotics researcher and tech manager, I can tell you exactly where the smart money and the top universities are actually looking.

The premium has shifted from pure coding to applied engineering and systems architecture. As I explored in my “4-Year Orchestrator Portfolio”: “By Year 4, you’re not wrestling with ‘how to wire a sensor’, you’re wrestling with architecture. That’s orchestration.” This principle holds true for hiring, admissions, and career trajectory.

While basic CS degrees are correcting, disciplines that merge software with the physical or analytical world are gaining immense traction:

Computer Engineering & Robotics: Understanding how software interacts with physical systems, edge computing, and hardware (IoT).

Data Science & AI Infrastructure: Not just using AI models, but building data pipelines, training models, and managing massive infrastructure.

Domain-Specific Tech Integration: Combining deep tech skills with another complex field—like computational biology, financial engineering, or aerospace.

Top-tier universities like MIT, CMU, and Stanford aren’t looking for kids who just took AP Computer Science and built a generic calculator app anymore. They are looking for students with a “builder mindset”, those who use technology to solve complex, ambiguous, real-world problems.

The distinction is critical: the visible artifact (the code, the app, the resume line) matters far less than the invisible infrastructure, the decision trees, the debugging protocol, the system design that other people can now use. That’s the technical strength that survives AI competition.

How to Stay Two Steps Ahead

If you are preparing a high school student for admissions into elite tech or engineering programs, here is how you leverage this market shift to your advantage:

Stop chasing the generic CS track: If your child’s application looks like every other applicant’s (high GPA, generic coding club, standard Python portfolio), they will get buried.

Focus on applied projects: Elite admissions officers want to see execution. Did they use AI to build a functioning tool for a local business? Did they dive into an FLL/FTC robotics build and solve a complex mechanical-software bottleneck? Did they ship a minimum viable product (MVP) to actual users?

Embrace the filter: The 8.1% drop in enrollment means your competition is shrinking. The crowd is running toward “safer” majors, leaving the field open for true builders who actually love the craft of engineering.

The cup isn’t half empty. It is emptying out the people who were only there for an easy paycheck. What remains is a highly lucrative, elite landscape for the next generation of technical leaders.

The Real Signal: System Thinking Over Syntax

You want to know the real difference between a student who will thrive in this new era and one who will struggle?

It’s not their coding speed. It’s whether they think like architects or like syntax processors.

The student who sees a broken system in their school, proposes a solution, documents the decision-making process, and then hands it off to the next generation, that student has built a strength. That student gets into MIT. That student lands the job.

The student who memorized sorting algorithms and can code fast? They’re competing with GitHub Copilot. And they’re losing.

Don’t let the headlines scare you. While the crowd panics and runs away from CS, we build. And the builders who understand that AI is a force multiplier, not a replacement, are the ones who will define the next decade of innovation.

Masaru
The Engineering Dad

P.S. If your student is in the “still figuring it out” camp, that’s exactly where the opportunity is. The 8.1% enrollment drop means the gatekeepers are hungry for students with genuine builder mentality. You have a two-year window to shift from generic CS to applied engineering. Start now.

Next: The Broader Context

If you want to understand how this fits into the bigger picture of CS college admissions, read:

• “From Science Fair to Salary: How to Turn High School Research into a Paid College Internship” — How to productize and monetize your projects

• “The Formal Program Trap: Why your 9th grader should build a lab, not join one” — Why independence beats institutional programs

• “Why ‘Looking for an Internship’ is the Worst Way to Find One” — How builders get recruited vs. how consumers apply

Ready to get more building started? My High School CS Toolkit includes:

• The 4-Year Orchestrator roadmap (what to build each year)

• 12 project archetypes (problems worth solving)

• The “Build in Public” playbook (how to document your journey)

• Real case studies from my own kids’ summer projects

The toolkit removes the guesswork. All you have to do is pick a problem and build.

Drop a comment and let me know what you are building.

Support the Workshop: I spend my spare cycles auditing the “Source Code” of admissions so you don’t have to. If you’ve found value in these logic gates, you can buy me a coffee ☕ to help keep this workshop running and the guides open-source.

Support the Workshop

Author: Masaru @ The Engineering Dad

Most high school students list their extracurriculars the way they list them on a résumé. Club president. Team captain. Volunteer coordinator. They’re hoping the title does the work. Admissions readers don’t care about titles. They care about what you built.

I know this because I’ve watched it for over a decade. Coaching competitive robotics teams at FLL, FTC, and FRC levels. Advising hundreds of families through college portfolios. Watching my own three kids navigate elite admissions (Cornell, Rice, and NEU), all of whom got in because they could articulate not “I ran X” but “I built Y that other people now use.”

As I’ve written before: “Hiring Managers (and top Engineering Colleges) are desperate for the Home Lab Kid.” The student who builds something in their garage, not someone who looks perfect on paper. The difference isn’t intelligence. It’s whether you’ve actually made something.

The gap between those two sentences is where most applications die.

The Three Levels Exist

When I work with a student on their portfolio, the first thing I do is map where they actually are. Not where they think they are. Not where the title suggests they are. Where they actually are.

I call this the Builder Delta framework. It has three levels, and understanding which level you’re at changes everything about how you talk about your work.

Level 1 is Systemic. You’ve identified a real problem in your environment and you can back it up with data. You see it, you understand why it matters, and you can articulate it. But you haven’t built anything yet. You have awareness. You don’t have an artifact.

Level 2 is Artifact. You’ve shipped something tangible. A tool. A system. A dataset. A curriculum. A script. A prototype. It exists. It works. You built it and it does what you intended. But here’s the thing, only you (and maybe your immediate team) are using it. It’s not adopted beyond its original context. You made something real, but it hasn’t scaled beyond your own effort.

Level 3 is Scaled. Your artifact is being adopted by others. A team. A school. A community. A public repository with contributors you didn’t train. It’s in use without you pushing it. The impact has multiplied because other people are using what you made. That’s Level 3.

Most high school students never leave Level 1 or 2. They spot a problem, they maybe build something, and then they stop. They list the activity on their Common App and wonder why it doesn’t land. They don’t realize they’re usually one move away from Level 3, and Level 3 is what makes admissions officers actually remember them.

From my experience working with hiring teams: “When the printer jams, they take it apart. They Google the error code. They fix it.” That’s the person admissions wants, that is someone who doesn’t ask for permission or instructions, but acts.

Why Titles Are Friction

Let me be direct. “Club president” is friction. It doesn’t tell an admissions reader what you did. It tells them you won a popularity contest or got voted in because you showed up consistently. Neither of those is a technical signal. Neither of those is evidence of builder thinking.

Here’s what colleges actually want to see: that you saw a constraint in your environment, you didn’t accept it as permanent, and you built a system to reduce it. And then you documented that system well enough that someone else could execute it. That’s a technical strength. That’s a transferable skill. That’s what transfers to a college team.

A robotics club president who says “I led my team to worlds” is fine. A robotics club president who says “I documented our debugging protocol so that next year’s captains could replicate our problem-solving approach faster” is differentiable. One is activity. The other is infrastructure.

The difference is usually about two weeks of focused work.

The “Builder Mindset” Is What Separates People

When I was hiring for research IT at a major Children’s Hospital, I had 150 resumes on my desk. 130 of them had a GPA above 3.8. 100 of them were from “Target Schools.” Almost all of them listed “President of [X] Club” or “Member of [Y] Society.”

Here’s what I did: “I deleted almost all of them.”

Instead, I applied what I call the “Toyota Test”, the instinct developed years earlier at Toyota Robotics to spot who could actually survive in a lab. And it wasn’t the perfect-on-paper student. It was the one who showed up and said: “I’ve been trying to build [X]. I hit this problem. Here’s my solution. Can I help reduce your team’s workload?”

That’s Level 3 thinking. You don’t ask to learn. You offer to be useful. The distinction between a consumer and a builder isn’t grades or prestige, it’s whether you’ve ever shipped something real that improves someone else’s life.

The Next Move Is Always Concrete

Here’s what I tell families when they’re stuck at Level 1 or 2: the path to Level 3 isn’t complicated. It’s not a grand reinvention. It’s usually one concrete move you can execute in 2 to 4 weeks with tools you already have access to.

An NHS president running a tutoring program who hasn’t shipped an artifact yet? Build a Google Form intake system that matches tutors to students. Document how many matches you make. That’s not revolutionary. That’s a 3-hour project that becomes proof that you can systematize work beyond just showing up.

A robotics team captain whose robot made it to states? Document the decision tree your team uses for debugging a mechanical failure. Record a quick video walkthrough. Leave it in a shared folder for next year’s team. That’s your artifact. That’s what makes you different on the application.

A soccer captain managing 11 players? Build a one-page positional reference card with the decision framework each position follows. Film a game. Annotate it with when your framework worked and when it didn’t. Iterate. That’s scaled because the next captain can use your framework and your team plays smarter as a result.

None of these require fancy tools. None of these require starting over. They require seeing what you’re already doing, extracting the technical layer, and documenting it in a way other people can use.

As I wrote in my 4-Year Orchestrator Portfolio: the framework evolves from “how do I wire a sensor” to “how do I architect a system?” That’s what amortization looks like. The first artifact is hard. Every subsequent one compounds.

The Common App Language Matters

When you’re ready to write about this on your application, specificity is your only weapon. Specificity is what separates memorable from forgettable.

Not this: “As robotics club president, I led my team to the world championship through dedicated leadership and teamwork.”

This: “Documented our team’s debugging protocol in a shared reference system adopted by next year’s captains, reducing average troubleshooting time per component failure by 45%.”

One is generic. Every club president says the first version. The second version is you, specific, measurable, and proof that you built something that other people use.

The constraint of the Common App essay forces you to be precise. That precision is actually the thing that makes you memorable. You don’t need more activities. You need to articulate the ones you have in the language of builder thinking.

Why I Built This Framework

I built the Builder Delta framework because I got tired of watching students undersell their actual work. They were building real systems, documentation, decision trees, debugging protocols, onboarding playbooks, and they didn’t even realize it was an artifact. They thought artifact meant a robot, or an app, or something grandiose.

Artifact just means “something real that other people use.” Your framework counts. Your documentation counts. Your tooling counts. Most high school builders are already at Level 2. They just need to see it, articulate it, and push it to Level 3.

And Level 3 is where admissions readers sit up and pay attention.

How to Get This Framework?

I’m submitting it to the Claude Code Skills Vault. It’ll be free, open-source, and customizable for any school or program.

What Happens Next

If you’re a parent reading this and your kid runs a club or leads a team but the application doesn’t feel like it captures what they’ve actually done, you now have a framework. Ask them what level they’re at. Ask them what artifact they’ve shipped. Ask them who is using it besides them. Those three questions will show you exactly where the gap is.

If you’re a student and you feel like your title should be more impressive than it sounds, it’s not you. You probably just haven’t extracted the technical layer of what you’re doing yet. That’s a two-week sprint. That’s not reinventing your entire summer.

I’m opening the Builder Delta audit to families who want to map out the next concrete move from where they are right now. Reply if you’re interested, and tell me what activity your student is running that feels like it should land harder than it does.

Because it probably should. You’re just one artifact away from Level 3.

Masaru
The Engineering Dad

P.S. If you’re an admissions counselor, coach, or educator watching students list activities without understanding they have artifacts to show for them, send this to them. The Builder Delta framework is free. The work is theirs. But at least they’ll know what they’re building toward.

Next: The Broader Context

If you want to understand how this fits into the bigger picture of CS college admissions, read:

• “From Science Fair to Salary: How to Turn High School Research into a Paid College Internship” — How to productize and monetize your projects

• “The Formal Program Trap: Why your 9th grader should build a lab, not join one” — Why independence beats institutional programs

• “Why ‘Looking for an Internship’ is the Worst Way to Find One” — How builders get recruited vs. how consumers apply

Ready to get more building started? My High School CS Toolkit includes:

• The 4-Year Orchestrator roadmap (what to build each year)

• 12 project archetypes (problems worth solving)

• The “Build in Public” playbook (how to document your journey)

• Real case studies from my own kids’ summer projects

The toolkit removes the guesswork. All you have to do is pick a problem and build.

Drop a comment and let me know what you are building.

Support the Workshop: I spend my spare cycles auditing the “Source Code” of admissions so you don’t have to. If you’ve found value in these logic gates, you can buy me a coffee ☕ to help keep this workshop running and the guides open-source.

Support the Workshop

Author: Masaru @ The Engineering Dad

Every summer, I see the same mistake: high-achieving students sign up for a “Python for Beginners” Coursera certificate. They spend 40 hours watching videos, click “Next,” and get a PDF that every recruiter in the country ignores.

If you want your child to stand out for a 9th-grade internship or a Tier-1 CS program, they need to stop consuming and start building.

The Problem with “Software-Only” Projects

When a student only writes code, they miss 50% of the engineering lifecycle. They don’t deal with power management, signal noise, or physical constraints.

A Hardware-Software Bridge project proves they can navigate the “Full Cycle”:

• Hardware: Assembling sensors and managing GPIO pins (= the nervous system of the Pi).

• OS: Navigating a Linux-based environment (Raspberry Pi OS).

• Code: Writing Python to handle real-world, messy data.

• APIs: Automating alerts to Discord or SMS.

As I wrote in my 4-Year Orchestrator roadmap: “Once a student builds their first hardware-software bridge, they’ve paid their ‘Technical Debt.’ Every project after that becomes faster, more complex, and higher-signal.”

That’s the inflection point. The first bridge is hard. Everything after is velocity.

The Project: The Local Insight Station

I have designed a starter project that is the perfect entry point. It’s a dedicated monitoring station that tracks local environmental data (Temperature, Humidity, and Motion) and logs it to a cloud dashboard.

Why this works for a Portfolio:

• It’s Tangible: They can show it to a hiring manager and explain the circuit.

• It’s Professional: It uses the same “Internet of Things” (IoT) logic used in industrial automation.

• It’s Low Cost: The total bill of materials is under $85.

The “Good Idea” Trap

I talk to parents every day who say, “This is a great idea,” but then the project never starts because they don’t know which Raspberry Pi to buy or which Python library to use.

To solve that, I’ve done the heavy lifting. I’ve put together a Complete Technical Blueprint that takes the guesswork out of it.

[Get the $5 Step-by-Step Blueprint on Gumroad]

In the full blueprint, I provide the exact shopping list, the wiring diagrams, and the starter code to get “Version 1.0” running in a single afternoon.

The Tech Dad Verdict: The difference between a college application that gets lost and one that opens doors is the difference between consuming and building. Start here. Pay the technical debt once, and watch your child’s velocity compound.

Next: The Broader Context

If you want to understand how this fits into the bigger picture of CS college admissions, read:

• “From Science Fair to Salary: How to Turn High School Research into a Paid College Internship” — How to productize and monetize your projects

• “The Formal Program Trap: Why your 9th grader should build a lab, not join one” — Why independence beats institutional programs

• “Why ‘Looking for an Internship’ is the Worst Way to Find One” — How builders get recruited vs. how consumers apply

Ready to get started? What to build after your first hardware-software bridge?? My High School CS Toolkit includes:

• The 4-Year Orchestrator roadmap (what to build each year): The Local Insight Station is the first brick in the 4-Year pipeline, not a standalone project.

• 12 project archetypes (problems worth solving)

• The “Build in Public” playbook (how to document your journey)

• Real case studies from my own kids’ summer projects

The toolkit removes the guesswork. All you have to do is pick a problem and build.

Drop a comment and let me know what you are building.

Support the Workshop: I spend my spare cycles auditing the “Source Code” of admissions so you don’t have to. If you’ve found value in these logic gates, you can buy me a coffee ☕ to help keep this workshop running and the guides open-source.

Support the Workshop

Author: Masaru @ The Engineering Dad

Today, let me shift a topic and introduce what I recently worked on that is related to builder mentality.

I’ve always advocated for a “Builder” mindset, the idea that students and professionals should create tangible projects rather than passively following a syllabus. Usually, I’m talking about Python scripts, agentic workflows, or Raspberry Pi clusters.

But recently, I stepped away from the screen to tackle a 1,000-lb structural challenge in my own backyard:

The 10x20’ Mirador Pergola Project.

Phase 1: The “Digital Twin” & The AI Controversy

Before a single bolt was tightened, I used AI-generated staging to visualize the final result. Here’s the before picture.

Recently, there’s been news about realtors being frustrated with AI staging because it “hallucinates” house structures, moving windows or walls. To many, this is proof that “AI doesn’t work.” But to a builder, that is simply using the tool wrong. I didn’t use the AI image to replace reality; I used it as a Conceptual Prototype. It gave us the “North Star” for the design, which I then cross-referenced against physical constraints. Here’s the prototype picture (AI generated):

This is exactly the distinction I explore in my “AI Survival Audit”: AI is fantastic at writing code for a web browser, but it is terrible at navigating the messy, unpredictable physical reality of the world.

In Tech: This is why I often advocate for Computer Engineering (CE) over pure Computer Science. CE is the intersection of software and physical hardware. An algorithm can write a script, but it cannot yet design a physical microchip or calibrate a robotics system in a lab.

A builder uses AI as a tool within that reality, never as a replacement for it. The digital twin was my North Star. The engineering was mine.

Phase 2: Compliance by Design (The 200 Sq. Ft. Rule)

Every project exists within a framework of constraints. In my jurisdiction, there is a “Magic Number” for outbuildings: 200 square feet.

The Constraint: Anything over 200 sq. ft. triggers a lengthy “Bureaucratic Latency” of architectural reviews and permits.

The Strategy: By selecting the 10x20’ footprint, the pergola sits exactly at the threshold.

By designing to this specific constraint, I moved directly from “Vision” to “Build.” It’s the same logic I teach in my College Internship Playbook: Understand the rules of the system so you can navigate them efficiently.

This is the core of the Builder mindset: moving from executing tasks to designing processes others can execute. Most people see constraints as limitations. But a builder sees them as the design specification.

I didn’t fight the 200 sq ft rule; I made it the North Star. That’s the difference between following rules and orchestrating within them. As I wrote in “Stop Waiting for Institutional Priorities”: understand the system so you can design to it, not around it.

Phase 3: Refactoring the Infrastructure (The 1,000-lb Load)

The kit assembly only took half a day, but the “invisible work” took much longer. A 10x20’ aluminum structure plus furniture and people adds up to over 1,000 lbs of static load.

Avoiding the “Punch-Through”: I spent the extra time ensuring the pergola legs were aligned directly over the underlying floor joists.

Manual Fortification: Where the footprint didn’t perfectly hit a joist, I went underneath to install concrete post bases and additional support pillars.

In software, we call this “Technical Debt.” In construction, skipping the foundation is the ultimate debt. I treated the floor reinforcement like a high-amp power supply for a Raspberry Pi 5: The stock setup works for “Hello World,” but if you’re running a heavy load, you have to beef up the hardware.

This is invisible work. No one sees the concrete post bases under the house. No one photographs the joist alignment. But as I explain in my “Builder vs. Consumer Framework”: the measurable change, the delta, lives in what’s hidden. If I left tomorrow and someone tried to use the pergola, it would stand. That’s not luck. That’s architecture.

The same logic I use to scope a pergola footprint is what's inside the project scoping section of the High School CS Toolkit.

The “Editorial Board” & The Subjective ROI

People ask about the cost-benefit ratio. Before the pergola, our backyard was “dead space.” Now, it’s my primary office.

If you have used my High School CS Toolkit, you have seen the “Supervising Editors” in the board notes, my three American Eskimo dogs (my daughter another Eskie, so that makes 4 total!!!) They have officially moved their headquarters to the patio sofa under the pergola. Because of the waterproof design and the structural reinforcement, they stay dry even in a Washington drizzle. To them, and to the human writing this, that is priceless.

This is what I call the “So What?” test. If the pergola just existed but didn’t function in a drizzle, it would be dead space again.

The question isn’t “What did it cost?” It’s “What changed because it exists?”

My dogs sleep dry. I work outside in rain. The system survives without me.

That’s the technical strength, and often I call as “moat”.

As I wrote in “The Builder vs. Consumer Framework”: “If you left the organization tomorrow, what system would break? If the answer is ‘nothing,’ you haven’t built a moat yet.”

Coming Soon: The Engineering Archive

I’ve decided to start documenting my past “infrastructure” projects here—not just for my own records, but as a case study for student engineers on how to apply technical logic to the real world.

Stay tuned for deep dives into:

The High-Availability Home: After a 7-day power outage in November 2024, I installed a generator power transfer panel and a battery backup system. My house now has a redundant power architecture that can keep most appliances running during a grid failure.

Systems Remodeling: The logic of tiling and electric heated floor systems in two bathroom remodels + official permit procedures.

Structural Physics: Building a high-tension zip line and stand, along with a custom playset, fence, and deck.

Mechanical Maintenance: Why I handle my own Lexus and Toyota maintenance, using OBD2 diagnostics and engine oil analysis to keep the fleet running.

Whether you are debugging a script or troubleshooting a generator transfer switch, the process is the same: Isolate the variable, test the hypothesis, and verify the fix.

This is what I call skill amortization, the same systems thinking applies whether you’re wiring a sensor or reinforcing a floor.

As I explore in my “4-Year Orchestrator Pipeline”: “By Year 4, you’re not wrestling with ‘how to wire a sensor’—you’re wrestling with architecture. That’s orchestration.” The medium changes. The craft stays constant.

Keep building.

To help you follow along with today’s builder strategy, grab your CS/Engineering Toolkit copy here before we dive into the breakdown. Find your perfect project to work on in the summer!

📥 Download the CS Toolkit

Drop a comment — what's one invisible system in your house or project that nobody sees but everything depends on?

Support the Workshop: I spend my spare cycles auditing the “Source Code” of admissions so you don’t have to. If you’ve found value in these logic gates, you can buy me a coffee ☕ to help keep this workshop running and the guides open-source.

Support the Workshop

Author: Masaru @ The Engineering Dad

To the parents of the Class of 2027:

Last week, my deep-dive briefing on the 11th Grade Redline saw the highest engagement in the history of this workshop log. It’s clear you recognize a critical system constraint: the production window for an 11th grader to ship a technical moat before the fall application boot phase is rapidly closing.

To move your student from theory to execution over the next 90 days, I have officially compiled the print-ready, high-compression 12-Week Portfolio Sprint Checklist PDF.

But we aren’t going to just pass this out like a regular classroom syllabus.

If your student wants to be an elite Systems Engineer or land at a Tier-1 CS program, they must move from a passive Consumer to an active Builder. Real engineers do not get hand-held copy-paste scripts; they navigate messy, unstructured constraints.

So, we are treating this deployment like a mini-hackathon challenge. Consider this their first step in passing the “Ambiguity Test.” The blueprint is encrypted, and they have to execute the protocol to unlock the payload.

STEP 1: Download the Locked Payload

Click the secure node below to pull the password-protected file down from Google Drive:

[📥 Download the Encrypted 12-Week Sprint PDF (Google Drive Node)]

Technical Log Note: This checklist is designed to provide high-level architectural guidance, not a step-by-step programming tutorial. Students are expected to aggressively resource the Internet to debug and execute each week’s sprint independently. If they hit a strict hardware or logic blocker, leave a comment directly on this post log, and I will step in to provide further code guidance/reviews.

STEP 2: Execute the Manual Handshake (Find the Passcode)

Because X is currently performing a manual “Safety Label Refresh” on my network account, direct link routing is heavily throttled on their platform. To extract the passcode flag and decrypt the PDF blueprint, have your student run this manual system override:

1. Open X and manually search for my handle: @engr_dad_cs (typing it directly into the search bar overrides the discovery filter).

2. Open the profile and view the Pinned Post.

3. The decryption passcode is hidden inside the first comment layer directly beneath the tweet.

Once your student grabs the flag, drop a Like and Bookmark on that X log layer. This manual handshake signals to the indexing servers that our node is a high-intent destination, flushing the platform cache and keeping these open-source pipelines running for our community.

The game is live. Let’s see if your student can navigate the protocol.

Build the infrastructure, don’t just follow the recipe.

Best,

Masaru
The Engineering Dad

Next: The Broader Context

If you want to understand how this fits into the bigger picture of CS college admissions, read:

• “From Science Fair to Salary: How to Turn High School Research into a Paid College Internship” — How to productize and monetize your projects

• “The Formal Program Trap: Why your 9th grader should build a lab, not join one” — Why independence beats institutional programs

• “Why ‘Looking for an Internship’ is the Worst Way to Find One” — How builders get recruited vs. how consumers apply

Ready to get started? My High School CS Toolkit includes:

• The 4-Year Orchestrator roadmap (what to build each year)

• 12 project archetypes (problems worth solving)

• The “Build in Public” playbook (how to document your journey)

• Real case studies from my own kids’ summer projects

The toolkit removes the guesswork. All you have to do is pick a problem and build.

Drop a comment and let me know what you are building.

Support the Workshop: I spend my spare cycles auditing the “Source Code” of admissions so you don’t have to. If you’ve found value in these logic gates, you can buy me a coffee ☕ to help keep this workshop running and the guides open-source.

Support the Workshop

Author: Masaru @ The Engineering Dad

If You Missed My Last Post

I outlined the Builder vs. Consumer framework, why a perfect resume isn’t enough and why the Ivy League is looking for orchestration, not participation.

Today: your concrete action plan to make the shift before summer starts.

With school ending in weeks and summer approaching, now is the moment to transition from passive consumption to active building. If you wait until July, you’ll default back to old habits.

The Question You’re Actually Asking

Most parents ask me: “Which summer program or online certification will help my kid stand out for CS admissions?”

It’s a logical question built on a flawed premise.

Instead, ask: “What will they build this summer that makes programs irrelevant?”

If you’re serious about that pivot, here’s the playbook.

Pre-Summer Prep: The Mindset Shift (Do This Before School Ends)

Identify the “Pain”

Look around your house, your hobby, or your community.

What is a manual, boring, or broken process?

A Builder project always starts with a problem, not a textbook.

Examples:

• Your parents spend 2 hours a week organizing family finances manually → build an automated dashboard

• Your robotics club wastes time re-documenting old projects → build a searchable archive system

• Local small businesses don’t have an online presence → build them a simple website

• Your community has no way to track local environmental issues → build a mapping tool

• Your school’s club coordinator uses a paper list to track members → build a digital roster with auto-emails

The key: Pick something that actually bothers someone, not something from a syllabus.

Assemble Your “Local Stack”

You don’t need a corporate budget or a $5,000 summer program.

Set up a local development environment. Experiment with agentic workflows—using tools like Claude, Anthropic’s API, or Raspberry Pis to act as your “force multipliers.”

The “Vibe Coding” era means the barrier between an idea and a working prototype is thinner than ever.

The only thing standing in the way is the willingness to start without a guide.

As I wrote in “The $0 Vibe Coding Stack”: You don’t need expensive tools. You need curiosity and a willingness to iterate.

Find a “Client”

This could be:

• A local non-profit

• A small business

• A family member with a genuine problem

• Your own school or club

Building for someone else introduces real-world constraints that a classroom never can.

Suddenly, your code needs to be reliable. Your documentation needs to be clear. Your solution needs to work.

That’s where learning happens.

The Pre-Summer Builder Checklist

Complete these before the final school bell rings. This determines whether the next three months are spent creating or just participating.

[ ] Identify One “Useless” Credential

Look at your summer schedule.

Identify one camp or certificate that is just “resume filler”—another tutorial-based course where you follow instructions.

Consider swapping it for 40 hours of deep, self-directed building on a real problem.

As I explored in “Why Summer Camps Don’t Work (And What to Do Instead)”: The best summer isn’t the one with the most prestigious name. It’s the one where you shipped something real.

[ ] The Portfolio Audit

If you had to show a recruiter a URL or a physical object you built today, what would it be?

If the answer is “nothing,” your first goal is to define that One Big Thing you’re building this summer.

Write it down. Make it specific. Not “build an app” but “build an automated energy audit tool for my home that measures how much I could save monthly.”

[ ] Set Up the “Lab”

Create a physical or digital space where building is the primary activity, not an afterthought.

Whether it’s:

• A corner of the garage for robotics and hardware

• A local AI server on an old laptop

• A GitHub organization for software projects

• A design space for prototyping

This is your “place to build.” Make it sacred.

To help you audit your workspace, I’ve pinned a tactical 'Pre-Summer Lab Checklist' to my X profile (@engr_dad_cs). This guide includes the specific hardware specs and local AI stacks I recommend for a 'Zero-Cost' home lab. Because X is still re-indexing my technical logs, you may need to manually search for my handle in the search bar to find the post. This manual search activity directly helps the discovery engine restore my public visibility while giving you the technical blueprint for your summer build.

[ ] Find a “Client” or Problem Space

Commit to building something for someone, not at someone.

This introduces:

• Real deadlines (not artificial ones)

• Real feedback (not grades)

• Real constraints (not textbook scenarios)

• Real impact (not busywork)

Email someone. Call someone. Ask: “I’m building a solution for X. Would you be interested in testing it?”

Yes, it’s scary. That’s the point.

[ ] Public Accountability

Commit to a “Build in Public” habit.

Choose one:

• Weekly GitHub commits with clear commit messages

• A Substack update documenting your progress (even if it’s messy)

• A YouTube series showing your failures and fixes

• A blog post explaining what you learned each week

A public trail of your building process is more valuable to an admissions officer or recruiter than a polished final product.

Why? Because it shows problem-solving in action, not just problem-solved.

The Summer Timeline

Week 1-2: Setup & Iteration Zero

• [ ] Set up your lab (GitHub, hardware, workspace)

• [ ] Meet with your “client” and understand the real problem

• [ ] Build the “dumbest possible” version that works

• [ ] Deploy it, even if it’s rough

Goal: First version shipped. Not perfect. Shipped.

Week 3-4: V1 Hardening

• [ ] Gather feedback from your client/users

• [ ] Document what you built (README, setup instructions)

• [ ] Fix critical bugs

• [ ] Make it reliable (your client should be able to use it without you explaining everything)

Goal: Reliable MVP in the hands of real users

Week 5-6: V1.1 & Feature Addition

• [ ] Analyze what’s actually being used vs. what isn’t

• [ ] Add one significant feature based on feedback

• [ ] Write a blog post or Substack explaining what you learned

• [ ] Make your GitHub public (if not already)

Goal: Show iteration based on real feedback, not your gut

Week 7-8: Productization & Case Study

• [ ] Polish documentation

• [ ] Capture measurable impact (how many people used it? what changed because of it?)

• [ ] Write your case study (the narrative you’ll use in college essays)

• [ ] Deploy it in a way that survives the summer (it works if you’re not there maintaining it)

Goal: Portfolio piece ready to share with admissions officers

What You’re Actually Building (Hint: It’s Not Just Code)

You’re not building an app. You’re building:

1. Proof of Problem-Solving — You identified a real problem and solved it

2. A Technical Trail — GitHub commits, documentation, iteration history

3. Real-World Constraints — You dealt with a client, deadlines, feedback

4. Measurable Impact — Your solution changed something about someone’s life

5. Communication Skills — You documented what you built so others could understand it

This is what gets you recruited by top colleges. Not the feature set. The evidence that you can think.

The Summer Goal

The goal for this summer isn’t to be a better student.

The goal is to become the person who makes the “student” label obsolete.

To move from asking “What do I need to do to get into MIT?” to asking “What problem can I solve that only MIT can help me scale?”

Common Objections (And Why They’re Wrong)

“But I’m not experienced enough to build something real.”

Perfect. Your client doesn’t care about your credentials. They care about their problem. Build for them.

“What if my solution is simple? Won’t that hurt my chances?”

Simple + shipped > complex + never finished. Admissions officers know this.

“What if it fails?”

Failure documented is better than success hidden. Show the iteration. Show you learning.

“What if I can’t find a client?”

Build for yourself. Your family. Your club. Your school. There are plenty of problems.

From Today Forward

This week:

• Identify your problem

• Sketch the MVP

• Find your client

Next week:

• Set up your lab

• Start coding/building

• Commit to public accountability

Before school ends:

• Have a working prototype

• Deploy it somewhere (even if it’s just your garage)

• Start documenting the journey

Summer:

• Execute the timeline above

• Build in public

• Measure impact

• Tell the story

Your Edge

By the time other 10th and 11th graders are scrolling through “Top 10 Summer Programs for CS,” you’ll have:

• A shipped product

• Real user feedback

• A GitHub history

• A case study

• Proof you can solve problems

That’s the technical strength, and differentiation you bring in to stand out.

Next: The Broader Context

If you want to understand how this fits into the bigger picture of CS college admissions, read:

• “From Science Fair to Salary: How to Turn High School Research into a Paid College Internship” — How to productize and monetize your projects

• “The Formal Program Trap: Why your 9th grader should build a lab, not join one” — Why independence beats institutional programs

• “Why ‘Looking for an Internship’ is the Worst Way to Find One” — How builders get recruited vs. how consumers apply

The Real Ask

This summer doesn’t belong to a camp.

It doesn’t belong to a certification.

It belongs to you.

Use it to build something that proves you’re not a Syllabus Consumer anymore.

That’s your edge.

Ready to get started? My High School CS Toolkit includes:

• The 4-Year Orchestrator roadmap (what to build each year)

• 12 project archetypes (problems worth solving)

• The “Build in Public” playbook (how to document your journey)

• Real case studies from my own kids’ summer projects

The toolkit removes the guesswork. All you have to do is pick a problem and build.

Drop a comment and let me know what you are building.

Support the Workshop: I spend my spare cycles auditing the “Source Code” of admissions so you don’t have to. If you’ve found value in these logic gates, you can buy me a coffee ☕ to help keep this workshop running and the guides open-source.

Support the Workshop

Author: Masaru @ The Engineering Dad

The Pattern I Keep Seeing

I am a Tech Dad of 3 CS grads. I have seen this before and we see it every year.

A high-achieving student presents a resume that is virtually perfect: 150+ volunteer hours, President of three clubs, Varsity athletics, and a list of summer programs that would make a Fortune 500 CEO sweat.

And yet, many of these students are met with “Waitlisted” or “Denied” from Tier-1 institutions like MIT, Cornell, or Stanford.

Why?

Because they are world-class Consumers, but the Ivy League is looking for Builders.

To help you follow along with today’s builder strategy, grab your CS/Engineering Toolkit copy here before we dive into the breakdown. Find your perfect project to work on in the summer!

📥 Download the CS Toolkit

What It Means to Be a Consumer

As I wrote in “Stop Waiting for Institutional Priorities to Choose You”, the real issue is this:

“They did everything they were told. They followed the script, checked the boxes, and mastered the material handed to them. But in the AI era, being a world-class consumer is a replaceable skill.”

The distinction matters because it’s not just about admissions—it’s about utility.

In a world where AI can follow instructions perfectly, colleges are no longer impressed by students who are “Master Chefs of the Recipe Book.” They are looking for students who can identify a recipe that doesn’t exist and create it.

A Consumer thinks:

• More volunteer hours = stronger application (wrong; impact per hour matters)

• Leadership titles = competitive advantage (wrong; systems you built matter)

• Perfect grades + test scores = admissions (wrong; what you built with that knowledge matters)

A Builder thinks:

• Can I solve this problem in a way that scales?

• Will this system work without me in the room?

• What measurable change did I create?

• Who else can I help using what I just built?

The Case Study: A Bio-Medical Powerhouse

I recently reviewed a phenomenal foundation from a high school junior: Robotics President, hundreds of community service hours, and a custom-designed Biomedical Engineering (BME) device for the elderly.

On paper, she is in the top 1%. But in the high-stakes Ivy lottery, she is “standard excellence.”

Why?

Because her narrative is participation-focused, not impact-focused.

She “designed” a device.

She “led” the robotics team.

She “volunteered” with the elderly.

But she never moved from consuming the structures that already exist to orchestrating new ones.

To stand out, she needs to move from participating in existing structures to creating solutions where none existed.

We call this the Builder Pivot.

The 3-Step Builder Strategy

1. Productize the Project

Don’t just “design” a device and list it as a bullet point.

Document the CAD process, open-source the assembly guide, and gather hard data.

If you test a medical device in a nursing home, your “impact” isn’t the design—it’s the Delta (Δ) in independence you measured for the residents.

Ask yourself: What changed measurably because of what I built?

In my post “Why ‘Applied Intelligence’ is the New IQ”, I illustrated this distinction:

“Applied Intelligence isn’t about how much you know; it’s about what you can Orchestrate with what you know. It’s the ability to take a messy, unstructured real-world problem and build a technical ‘System’ to solve it.”

The student who raises $100k for a nonprofit and stops there is a Consumer.

The student who raises $100k and performs a Cohort Analysis to identify a 15% donor churn rate, then builds a data-driven re-engagement system that saves the non-profit $7,500 in recurring revenue?

That student is an Engineer of Systems.

Productizing means: Documentation → Data → Deployment.

Your project should have:

• A GitHub repo

• A README explaining the problem

• Evidence that real people benefited

• Measurable outcomes (not feelings or opinions)

  ---

  To help you visualize this shift, I've pinned a Resume 'Impact Delta' Template to my X profile (@engr_dad_cs). Because X is currently re-indexing my technical logs, you may need to manually search for my handle in the search bar to view it. This search activity helps the system restore my public visibility while giving you a plug-and-play framework for your next project.

  ---

2. Bridge the Skill Gap Through Orchestration

If you are a Media Manager for a club, don’t just post photos.

Build a system.

Create a digital “Playbook” that other clubs can use to scale their engagement.

If five other organizations use your system to grow their reach by 40%, you are no longer a volunteer—you are a Systems Architect.

This is the core of the Builder mindset: moving from executing tasks to designing processes others can execute.

My “4-Year Orchestrator Portfolio Pipeline” breaks this down across four years:

• Year 1 (9th): Build one thing (prove curiosity + technical literacy)

• Year 2 (10th): Reapply that technical stack to a different problem (prove versatility)

• Year 3 (11th): Integrate advanced tools like ML or Signal Processing (prove academic depth)

• Year 4 (12th): Move from breadboard to custom PCB / professional MVP (prove maturity)

The magic isn’t in doing four separate projects.

It’s in the skill amortization: 70% of Year 1’s code gets reused in Year 2, freeing you to focus on new complexity.

By Year 4, you’re not wrestling with “how to wire a sensor”—you’re wrestling with architecture.

That’s orchestration.

3. The “So What?” Test

Look at every bullet point on your resume.

If the result is simply “I was there” or “I led the meeting,” it isn’t enough.

Tier-1 schools want to see the measurable change your presence created.

If you left the organization tomorrow, what system would break?

If the answer is “nothing,” you haven’t built a moat yet.

How This Shows Up on Your College Application

A common concern for parents: where do I fit this “Builder” work in a limited word-count application?

Here is the secret: The project IS the personal statement.

Your essay shouldn’t just be a narrative about “passion.”

It should be a technical and emotional defense of your Technical Moat.

As I explored in “The ‘AI Moat’: How to Stop the Career Panic and Start Building the Future”:

“A ‘CS’ degree with an ‘AI Concentration’ is just a label; a portfolio of deployed AI agents that solve real problems is a resume.”

The same principle applies to your application narrative.

Your essay should:

1. Describe the moment you saw a problem in the “Wild” (outside the classroom, outside the syllabus)

2. Explain how you orchestrated a solution (not just participated in one)

3. Show the data that proves impact

4. Use the “Additional Information” section or a Portfolio link to attach:

   • CAD files

   • GitHub repos

   • Deployment evidence

   • Measurable outcomes

Admissions officers are drowning in essays about “passion for STEM.”

What they hunger for is evidence of problem-definition.

Show them you don’t just execute recipes—you identify which recipes the world needs and cook them.

The Consumer vs. Builder Mindset Applies Everywhere

The distinction between Consumer and Builder isn’t just about admissions.

It applies to internships, careers, and life.

As I wrote about extensively in “Why ‘Looking for an Internship’ is the Worst Way to Find One (And What to Do Instead)”:

“To actually secure a role, students must transition from a passive ‘Consumer’ mentality (asking for an opportunity) to an active ‘Builder’ mentality (demonstrating immediate value).”

A Consumer asks: “How do I get into MIT?”

A Builder asks: “What problem can I solve that only MIT can help me scale?”

A Consumer’s strategy: Apply to 15 schools, hope one says yes, optimize for “safety” schools.

A Builder’s strategy: Identify the specific problem space where you have a technical moat, find the schools with the strongest research groups in that space, and position yourself as someone who can contribute to that research from day one.

Why This Matters Right Now

The Science Fair is a “Controlled Environment.”

Everyone is on the same track.

The “Wild” is the local community, the cafeteria, the non-profit, the business, the real world.

Builders thrive in the Wild because they don’t wait for permission to lead.

The question isn’t which summer program to attend.

The question is: What will you build that makes summer programs irrelevant?

That’s the edge. That’s the moat. That’s how you get off the waitlist.

Your Next Move

You now understand the framework.

The Builder vs. Consumer distinction is everything.

But understanding isn’t enough. You need to know how to execute this.

My Next’s post walks you through the concrete pre-summer action plan—the checklist, the lab setup, the client acquisition, and the public accountability that transforms you from Consumer to Builder in the next 8 weeks.

If you’re ready to move now, here’s what to do:

1. Identify your problem space. What frustrates you in your daily life that others are ignoring?

2. Think small. Not a world-changing project—something you can prototype in the next 30 days.

3. Find one person who has that problem and would benefit from your solution.

Next post: the full action plan.

Related reading from the archive:

• “Confessions of a Tech Hiring Manager: Why I Ignore 4.0 GPAs” — What hiring managers actually care about

• “The Formal Program Trap: Why your 9th grader should build a lab, not join one” — Permission is your enemy

• “The AI Survival Audit: How to Build a ‘Career Fortress’ for the Class of 2033” — Why moats matter now more than ever

• I've pinned a tactical 'Impact Delta' Template to my X profile (@engr_dad_cs). If the link doesn't resolve, please manually search for my handle, it’s the fastest way to help me break the current search throttle and get these resources back into the public feed.

Want the full roadmap? My High School CS Toolkit breaks down the exact frameworks, portfolio ideas to transition your student from Consumer to Builder before they even apply to college.

Drop a comment and let me know what you are building.

Support the Workshop: I spend my spare cycles auditing the “Source Code” of admissions so you don’t have to. If you’ve found value in these logic gates, you can buy me a coffee ☕ to help keep this workshop running and the guides open-source.

Support the Workshop

I am a Tech Dad of 3 CS grads. The hype cycle around AI (Artificial Intelligence) is exhausting. If you’re a student right now, whether you’re in Computer Science or a Data Analytics track, you’ve likely been bombarded with terms like “Neural Networks,” “Parameters,” and “Fine-Tuning.”

But there is a massive gap between watching a YouTube video about how AI works and actually controlling one yourself. For a long time, the barrier to entry was high: you needed a $2,000 GPU, a complex Linux setup, and a PhD-level understanding of Python environments.

That has changed.

If you want to stop talking about AI and start building with it, you need to know about two things: Unsloth and Google Colab.

To help you follow along with today’s builder strategy, grab your CS/Engineering Toolkit copy here before we dive into the breakdown. Find your perfect project to work on in the summer!

📥 Download the CS Toolkit

The “Secret Sauce”: Unsloth

Most AI models are “heavy.” They require massive amounts of memory (VRAM) to train or tweak. Unsloth is an open-source framework that makes fine-tuning Large Language Models (like Llama 3 or Mistral) up to 2x faster and uses 70% less memory.

For a student, this is the “holy grail.” It means you can run professional-grade AI on free hardware.

Your First Project: The “Run and Play” Method

We’re going to skip the 50-page textbook and go straight to the Unsloth Studio. This is designed specifically for people who want to see results immediately.

Step 1: Open the Sandbox

You don’t need to install anything on your computer. We use Google Colab, which is essentially a “Google Doc for Code.” It provides you with a free GPU (a powerful processor) in the cloud.

Click here to open the Unsloth Studio Colab

Step 2: The “Play” Button

Once the page opens, you’ll see blocks of code (cells).

1. Look for the “Connect” button in the top right corner to grab your free GPU.

2. Hover over each bracket [ ] on the left side of the code blocks and click the Play icon.

Step 3: What are you actually doing?

As you click through, the notebook is doing the following:

• Installing Unsloth: Setting up the engine.

• Loading a Model: It’s pulling a “base” model (like a blank-slate Llama 3) from the internet.

• Formatting Data: It takes raw text and turns it into a format the AI can learn from.

• Fine-Tuning: This is the magic. The model “studies” the specific data you gave it to become an expert in that specific area.

Why this matters for your career

For CS Students:

You need to understand the infrastructure. Seeing how Unsloth optimizes kernels and manages memory gives you a deeper look into “Efficient ML (Machine Learning).” It’s one thing to call an OpenAI API; it’s another thing to understand how to make a model run on restricted hardware.

For Data Analytics Students:

AI is just a new way to analyze data. Instead of just making a bar chart in Excel, you are now learning how to feed datasets into a model to predict text, summarize reports, or categorize sentiment. Fine-tuning is the ultimate data cleaning and processing skill.

Your “Homework” (The Fun Kind)

Once you get the Colab running, don’t just close the tab. Change the text in the “Dataset” section.

• Want the AI to talk like a pirate? Feed it pirate dialogue.

• Want it to summarize medical papers? Feed it abstract samples.

The Goal: Break it. Change the variables. See what happens when you increase the “epochs” (how many times the AI reads the data).

The “Magic” of AI disappears once you realize it’s just a tool you can turn on and off. Unsloth is the best remote control we have right now.

Ready to dive deeper? Check out the Unsloth GitHub to see the code behind the curtain.

Drop a comment and let me know what you are building.

Support the Workshop: I spend my spare cycles auditing the “Source Code” of admissions so you don’t have to. If you’ve found value in these logic gates, you can buy me a coffee ☕ to help keep this workshop running and the guides open-source.

Support the Workshop

Wait, what?? Did my child get off the wait list of her/his dream school?

These are messages I am seeing increasingly in parent forums in the last 48 hrs. The waitlist is a test of patience, but your career shouldn't be on hold.

The May 1st “National Decision Day” used to be the finish line. You’d wear the sweatshirt, post the commitment photo, and pay the deposit. But this year, the timeline is stretching. With some schools extending final decisions to May 7th and others just beginning to dip into their waitlists, many students are finding themselves in a state of “committed but still hoping.”

If you’ve deposited at School A but are staring at your inbox waiting for School B to call you off the waitlist, here is your tactical guide for the weeks (and potentially months) ahead.

1. Protect Your Current Seat

First thing’s first: Do not withdraw from the school where you deposited. Until you have a signed, official acceptance letter and a financial aid package from your waitlist school, you are a committed student at your current college. Treat that enrollment as final to ensure you have a housing assignment and a course schedule ready for August.

2. The Financial Reality Check

Before you get that “You’re In!” email, sit down with your family and discuss the “Walk-Away Price.”

• The Lost Deposit: Almost all enrollment deposits (usually $200–$600) are non-refundable. Accept that this money is gone if you switch.

• Financial Aid: Waitlisted students are often at a disadvantage for merit scholarships, as most of that money was distributed in the first round. Use a net price calculator now so you aren’t blinded by a massive bill in June. You might be able to negotiate merit in the last minute. See details here how to approach it.

3. The “Letter of Continued Interest” (LOCI) 2.0

If the school extended their deadline to May 7th, they are currently gauging their yield. If you haven’t sent a brief, professional update recently, do it now.

• Keep it punchy: Reiterate that they are your #1 choice and you would enroll immediately if accepted.

• New News: Mention any final grades, new awards, or projects completed since April.

  ---

  While You Wait: Start Building the Career

  Whether you end up at your reach school or your current commitment, the degree is only half the battle. Don’t rebuild the wheel while you’re in limbo. I’ve templated the exact “Internship Ladder” that took my kids from 9th-grade interns to Cornell and Rice grads.

📥 Download the System Level Blueprint

4. The Summer Roadmap: May through August

Waitlist movement happens in waves. Here is how to prepare for each phase:

5. Managing the “Double Deposit” Ethics

Standard practice in college admissions is that you should only be deposited at one school at a time. However, it is entirely legal and ethical to stay on a waitlist after depositing elsewhere.

The moment you accept a waitlist offer:

1. Pay the new deposit.

2. Immediately notify the first school that you are withdrawing your enrollment.

3. Do not “double deposit” for more than 24–48 hours; it takes a spot away from another student and can lead to complications with final transcripts.

The Bottom Line

The waitlist is a marathon, not a sprint. It requires a difficult mental balance: Fall in love with the school you’re attending, but keep your bags packed for the one you want. Stay patient, stay professional, and keep an eye on that inbox. The “Summer Shuffle” has only just begun.

Don’t Just Wait—Prepare

If the waitlist doesn’t move, remember: your success isn’t defined by the name on the gate, but by the projects you build once you’re inside. To get a head start on the “Builder” mindset before classes start in August, check out my proven framework.

I’ve templated the exact “Internship Ladder” that took my kids from 9th-grade interns to Cornell and Rice grads.

📥 Download the System Level Blueprint

P.S. In case you missed it, I had a wild 72 hours fighting an AI lockout on X. You can read the full breakdown of how I used a 'Technical Defense' to get the account restored here.

I’m a Tech dad of 3 CS grads (Cornell and Rice chosen over Caltech/Columbia).

I recently watched a heartbreaking interaction in a college admissions group. A parent was celebrating, rightfully so, that their daughter was a valedictorian with a 4.5+ GPA, 10 AP classes, and two Associate Degrees (90+ college units) completed before high school graduation. She was accepted to every UC, including Berkeley and UCLA.

Then, the “Consumer” reality hit the “Builder” requirements of a STEM degree.

Despite having nearly 100 units, the student realized she still needs four full years to graduate. Why? Because while she was “collecting gold stars” in the form of general education credits, she hadn’t started the technical clock.

To help you follow along with today’s builder strategy, grab your CS/Engineering Toolkit copy here before we dive into the breakdown.
📥 Download the CS Toolkit

The Reality is the Prerequisite Bottleneck

In liberal arts or general business, credits are often fungible. You can swap one history elective for another and move closer to the finish line. In STEM (Computer Science, Engineering, Biotech), the degree is governed by a Critical Path.

The degree is a chain, not a bucket.

If you don’t have Calculus I, you can’t take Physics. If you don’t have Physics, you can’t take the upper-division Engineering core. If you don’t have the CS fundamentals, you can’t take the systems courses.

You can enter a university with enough credits to be a “Junior” by status, but if you haven’t cleared the specific math and science sequences, you are effectively a Freshman in your major. The university doesn’t care if you have 90 units of sociology and art history; if you aren’t ready for Multivariable Calculus, your four-year clock hasn’t even started ticking.

The Strategy is to Prioritize the “Critical Path”

For parents of high-achieving students, the goal shouldn’t be “getting an AA degree.” The goal should be clearing the Physics Tax and the Math Sequence early.

If your student is aiming for a top-tier STEM program, the only credits that truly move the needle on graduation time are:

• AP Calculus BC / Multivariable Calculus / Linear Algebra

• AP Physics C (Mechanics and E&M)

• Introductory CS (Data Structures/Algorithms)

Doing these as Dual Enrollment (DE) or AP credits is what actually clears the path. Anything else is just “padding” that might get you into the school, but won’t get you out of the school any faster.

The Financial “Donut Hole” is Real

This becomes a massive financial crisis for the middle class. The family I mentioned received $0 in aid from the FAFSA. They are in the “Donut Hole” earning too much for Pell Grants, but not enough to write a $40k check for four years without feeling the pain.

Perhaps, they thought the AA degrees were a “scholarship” worth two years of tuition. Instead, they are looking at a four-year bill they didn’t budget for because they focused on the prestige of the degree rather than the logic of the curriculum.

The Verdict

In the AI era, the “Processor” student collects credits and hopes for the best. The “Builder Orchestrator” understands the architecture of their degree.

Don’t let your student spend four years in high school working for college credits that don’t actually count toward their technical moat. Prioritize the sequence, clear the math bottleneck, and focus on the portfolio.

The goal isn’t just to get accepted, it’s to graduate with your technical velocity (and your bank account) intact.

If you think a sample high school course sequence is beneficial, leave a comment below.

Support the Workshop: I spend my spare cycles auditing the “Source Code” of admissions so you don’t have to. If you’ve found value in these logic gates, you can buy me a coffee ☕ to help keep this workshop running and the guides open-source.

Support the Workshop

I am a Tech Dad of 3 CS grads.

The May 1st deadline is not just a decision day; it is the final minute of a high-stakes negotiation. If you are staring at a “dream school” acceptance but a nightmare tuition bill, it’s time to stop being a “Syllabus Consumer” and start acting like a “Builder.”

To help you follow along with today’s builder strategy, grab your CS Toolkit copy here before we dive into the breakdown and merit negotiation scripts.
📥 Download the CS Toolkit

I have navigated the high-stakes world of elite college admissions three times. My children didn’t just get into top CS programs like Cornell and Rice, they did so with strategic financial outcomes, including one child choosing a full-ride scholarship at Rice over offers from Caltech and Columbia. As a Technical Program Manager with a decade of coaching robotics and a background in industry research at Toyota, MIT, and CMU, I view the admissions process as a system that can be optimized. I’ve seen firsthand how a “Builder” portfolio, demonstrating real-world technical strength, provides the leverage needed to win the merit aid game.

I know exactly how you feel right now. You’ve done everything right: the late-night study sessions, the SAT prep, and the grueling application season. But now that the acceptance letters are in, a new fear has set in: “Can we actually afford this?” You might be worried that asking for more money will jeopardize the admission, or perhaps you feel that a high GPA should have been “enough.” The stress of choosing between your child’s dream school and a massive debt load is overwhelming. But remember: the university is a business, and you are in the final stage of a high-value transaction. Your anxiety is a signal to act, not to freeze.

To get the most merit aid, we must move beyond emotional pleas and use logical leverage. The initial financial aid package is rarely the university’s “final offer”; it is a baseline based on stale data. Universities are looking for ROI. A student who has built an at-home lab, contributed to open-source AI, or held a paid internship since 9th grade is a lower risk for the university. We highlight these “Builder” traits as proof that the student will enhance the school’s prestige and career placement stats.

Here’s the approach you should take:

If School A is ranked similarly to School B, but School B offered $10k more in merit aid, that is a logical data point. Universities often have “match” policies, but they won’t volunteer them unless you present the comparison. Here is your 72-Hour Action Plan:

• Hour 1-24: Gather Leverage. Collect “competing” offers from peer institutions and update your child’s “Builder” portfolio with any recent wins such as new projects, GitHub commits, or internship leads.

• Hour 25-48: The Re-evaluation Request. Submit a formal request to the financial aid office. Use specific, professional language: “This institution is our top choice, but the current financial gap makes the ROI difficult to justify compared to our other competitive offers.”

• Hour 49-72: The Human Connection. Follow up via phone. Speaking to a human in the financial aid office often yields results that an automated system cannot. Explain the “gap” and ask if there are any departmental scholarships or discretionary funds still available for high-impact students.

College is the first major investment in your child’s professional strength. Don’t leave money on the table because of a passive mindset. Be a Builder. Negotiate with data. For the exact scripts and frameworks I used to secure a full ride at Rice, check out my High School CS Toolkit and the Internship Ladder guides.

Let’s get this last mile finished.

If you need more details of merit negotiation tactics, read this one next:

Drop a comment and let me know if you were able to negotiate merit.

Support the Workshop: I spend my spare cycles auditing the “Source Code” of admissions so you don’t have to. If you’ve found value in these logic gates, you can buy me a coffee ☕ to help keep this workshop running and the guides open-source.

Support the Workshop

Is your student a brilliant 11th grader with zero projects? They aren't 'behind', they are just 'unoptimized.' I’ve created a High-Compression Summer Sprint to help them build a 2-year portfolio in 12 weeks. Don't let their 4.0 GPA go to waste because they lack an Audit Trail.

Don't rebuild the wheel. I’ve templated the exact 'Internship Ladder' that took my kids from 9th-grade interns to Cornell and Rice grads.

📥 Download the System Level Blueprint

Tech Dad of 3 CS grads (Cornell, Rice chosen over Caltech/Columbia) here. When a student starts late, we move them from the “Learning Phase” to the “Production Phase” immediately. We don’t spend weeks on “Hello World”; we build a System from day one.

The “High-Compression” Roadmap

Strategic Adjustments for Late Starters

If a student is starting in 11th Grade, they are already in the “Redline” phase. They cannot afford to make mistakes that cost them weeks of time. They need to optimize for Signal Density.

• Skip the “Sandbox”: Instead of building a toy robot, they go straight to a project with Interdisciplinary Value (e.g., merging CS with Biology, Psychology, or Physics).

• Leverage the “Academic Engine”: Since an 11th grader is usually in Calculus or Physics, we use that math immediately in the code. This proves they aren’t just “coding for fun”—they are “engineering for results.”

• The “Double-Dip” Strategy: We align the summer project with a potential School Research Paper or a Science Fair entry in the Fall. This ensures they get “Triple-Credit” (GPA, Extracurricular, and Portfolio) for a single block of work.

The “Summer Runway” Logic: Why July is the most expensive month

For a 10th or 11th grader, July is the most valuable “Real Estate” in their high school career.

• 10th Graders: July is your last “Low-Stress” window to build a foundation.

• 11th Graders: July is your last chance to build a Technical Moat before the College Application “Boot Phase” begins in the Fall.

“Tech Dad” Warning: “If you wait until August of Senior year to start your first project, you aren’t an Orchestrator; you’re a Firefighter. You’re trying to put out a fire with a resume that has no signal.”

Get the Roadmap: If you want to move your student from a “Consumer” to an “Orchestrator,” my High School CS Toolkit contains the exact “Internship Ladder” and project list my own kids used to land at Cornell, Northeastern, and Rice.

Start building the “Home Lab” roadmap here: [Gumroad Toolkit]

P.S. In case you missed it, I had a wild 72 hours fighting an AI lockout on X. You can read the full breakdown of how I used a 'Technical Defense' to get the account restored here.

I am a Tech Dad of 3 CS grads. This is another special edition because something drastic that happened earlier this week (see the post below) and it’s been resolved.

Here is another Builder log.

Early this week, The Engineering Dad went dark.

For a Technical Program Manager and a former robotics researcher, there is a certain irony in being flagged by an algorithm for “Inauthentic Behavior.” One minute I was sharing insights on the “Builder vs. Consumer” mindset; the next, I was locked out of my own digital home.

If you’ve been following my work on the Internship Ladder or Vibe Coding, you know I advocate for a “Builder” mentality—identifying a problem and systematically engineering a solution. This week, the problem was me.

The Sequence of Events

For those of you navigating your own technical brands or helping your students build their digital footprints, here is exactly what happened and how I engineered the recovery:

1. The Trigger: A routine thread scheduled via a third-party tool triggered an automated “Inauthentic Behavior” flag. Total lockout.

2. The Deadlock: Standard mobile appeals failed. I was stuck in a loop of “rock counting” captchas that led to nowhere. No case number, no confirmation.

3. The Pivot: I moved from the mobile app to a Desktop Browser (in Desktop Mode). I treated the appeal like a technical Jira ticket—concise, professional, and citing my status as a Premium and Developer API subscriber.

4. The Handshake: I used Grok (X’s AI) to confirm my human status. By acknowledging the “Proof of Human” steps directly to the AI support channel, I moved my case from the “Spam Queue” to the “Premium Review Queue.”

5. The Result: 72 hours later, a human reviewer (or a higher-level AI) cleared the flag. “Our automated systems have determined there was no violation.”

The Lesson for Builders

This wasn’t just about a social media account. It was a stress test for the very philosophy I teach:

• Don’t rely on a single node: If I didn’t have this Substack and my Gumroad toolkit, my brand would have been erased. Always own your audience.

• Documentation wins: When I appealed, I didn’t just say “I’m not a bot.” I provided my professional credentials (TPM, CS/MBA) and a clear audit trail of what I was doing.

• Stay professional under pressure: Whether it’s a zoning board (like my recent 19-exhibit defense binder) or a tech suspension, the person who stays calm and cites the “Financial/Service Loss” usually wins.

What’s Next?

I’m back. The High School CS Toolkit is live on Gumroad, and I’m doubling down on the “Builder” curriculum. We’re going to talk more about “Technical Defense”—how to prove you (or your student) are the real deal in an era of automated noise.

I’m curious: Have any of you dealt with an “AI lockout” or a system-level glitch recently? How did you solve it?

Leave a comment below. It’s good to be back.

Masaru
The Engineering Dad

The Engineering Dad writes about CS career strategy, college admissions ROI, and the financial mechanics of getting your kid from high school to a software engineering role without destroying your retirement.

If you want to see the exact frameworks I use to help students navigate this path (including the merit aid negotiation template mentioned in my ill-fated thread), you can find it here:

The High School CS Toolkit & Merit Aid Template

Stay systematic.

Support the Workshop: I spend my spare cycles auditing the “Source Code” of admissions so you don’t have to. If you’ve found value in these logic gates, you can buy me a coffee ☕ to help keep this workshop running and the guides open-source.

Support the Workshop

I am a Tech Dad of 3 CS grads. The college admissions cycle often feels like a black box, and the advice given to parents and students is frequently designed to soften the blow of rejection rather than sharpen the edge of the application.

Recently, a viral post by a seasoned counselor laid out some “hard truths.” It focused on institutional priorities: the idea that schools might need more kids from South Dakota, more oboe players, or a specific gender balance to round out a class. The message to the student is: “You can be perfect and still get denied. It’s out of your control. Too bad, so sad.”

I fundamentally disagree with the passivity of that advice. While institutional priorities are a reality of the university “business model,” telling a student that their future is a coin toss based on geography or luck is a recipe for anxiety and stagnation. We need to stop treating students like passive participants in a numbers game and start treating them like the architects of their own ROI.

To help you follow along with today’s builder strategy, grab your CS Toolkit copy here before we dive into the breakdown.
📥 Download the CS Toolkit

The Commodity of the “Perfect” Student

The counselor was right about one thing: there is no shortage of “perfect” 4.0/1550 SAT kids. In the high-tier applicant pool, these numbers are no longer a “wow” factor, they are the baseline.

They get rejected because they are Syllabus Consumers. They did everything they were told. They followed the script, checked the boxes, and mastered the material handed to them. But in the AI era, being a world-class consumer is a replaceable skill.

If your child is “swimming in a pool of 1,500+ identical applicants,” it’s because they haven’t built a technical system or solved a real-world problem that separates them from the pack.

Flipping the Script: The Builder Portfolio

Institutional priorities are the school’s business. Your child’s business is proving they are a Builder.

A Builder Portfolio, a technical project, a coded solution, or a tangible “Maker” achievement, is the ultimate differentiator. It moves the conversation away from “Does the school want me?” to “What can I build that makes me indispensable?”

• Don’t wait for the “Rockstar” title: Counselors say it’s up to the kid to be a “rockstar” once they get to college. I say: Why wait? The “Class of 2025” devastation happened because families treated the Ivy League as a finish line.

• The Finish Line has moved: In this landscape, the finish line is the ability to orchestrate and build technical systems. If a student shows they can do that at 17, the “institutional priority” of where they are from matters a lot less than the value they’ve already created.

Mental Stability: The “No Dream School” Policy

We often overlook the mental toll of the “Dream School” trap. When my kids went through this process, I told them: Do not have a dream school. If a school doesn’t “love you back,” it’s usually because their business model doesn’t align with your career goals. That’s okay. Move on. When you focus on ROI and your own ability to build, your self-worth isn’t tied to an admissions letter from a specific zip code. That mental stability is a superpower that almost no one in this industry talks about.

The Bottom Line

The 2026 admissions landscape is a different beast. Birth rates are peaking, domestic volume is up, and the applicant pool is more diluted than ever with “perfect” students.

If you get denied, it isn’t just “too bad, so sad.” It’s a signal to pivot. Don’t be a passive participant in a system you can’t control. Build something that makes the system irrelevant.

There is always light at the end of the tunnel but you have to be the one holding the torch.

What are your thoughts on the “Builder vs. Consumer” mindset? If you’re navigating the 2026 or 2027 cycle, let’s discuss how to start building today.

Support the Workshop: I spend my spare cycles auditing the “Source Code” of admissions so you don’t have to. If you’ve found value in these logic gates, you can buy me a coffee ☕ to help keep this workshop running and the guides open-source.

Support the Workshop

I am a Tech Dad of 3 CS grads. This is a special edition because something drastic happened this week and this is something that many of you might experience.

Here is my Builder log.

The algorithm flagged me as a bot.

I wasn’t.

Here’s the exact system I used and what it taught me about building an audience from zero.

START

On Monday morning I had 29 followers on X and roughly zero impressions per day.

By Tuesday night I had 94K impressions, 1.3K likes, 47 bookmarks, 25 reposts, and 135 profile visits. I gained 7 new followers — verified, real people in my exact niche.

Wednesday morning at 6am my scheduled thread went live. By 6:15am the analytics showed Apr 22 was already matching Apr 21’s peak. The numbers were compounding.

At some point Wednesday morning, X suspended my account for inauthentic behavior.

I hadn’t spammed anyone.

I hadn’t used bots.

I hadn’t bought followers.

I had used a strategy so effective that their automated system couldn’t distinguish me from one.

That’s the story I want to tell you — because buried inside it is a system that works, and a lesson about what happens when you execute it too well on a platform that wasn’t expecting you.

To understand why my strategy triggered a 'bot' response, you first have to understand the logic of the pipeline I was building. I don’t believe in chasing 'vibes'; I believe in systems.

📥 Download the CS Toolkit

Think of this toolkit as the Technical Requirements Document (TRD) for what I’m about to break down. It’s the same logic I used to help my kids navigate the CS pipeline, and it's the same logic that—ironically—got me flagged by X for being 'too systematic.'

Why I Was Starting From Zero

I launched The Engineering Dad Substack on February 9, 2026.

The premise was simple:

I’m a Technical Program Manager, father of three kids who all majored in CS and landed software engineering roles, and I’ve spent over a decade co-coaching FLL, FTC, and FRC robotics teams. I know how the CS pipeline actually works — the internship sequencing, the merit aid negotiation, the difference between a builder mindset and a syllabus-consumer mindset.

The problem was that nobody on X knew I existed.

My account had 29 followers. Most of them were people I knew personally. My daily impressions were in the single digits. I was posting into a void.

I needed a different approach. Not more posts. A different strategy entirely.

The same systematic approach I use to debug a robotics sensor or negotiate merit aid is what I applied to X. I treated the platform like a logic gate.

The Insight That Changed Everything

Most new accounts on X try to grow by posting original content. The logic seems obvious:

create good content,

people find it,

people follow you.

The problem is math. When you post original content to 29 followers, X shows it to roughly those 29 people plus a small test sample. If those 29 people don’t engage immediately — and they won’t, because 29 people is nothing — the algorithm treats the post as low-confidence content and stops distributing it.

You’re not building an audience. You’re shouting into a room with 29 people in it.

The insight I tested was different:

instead of creating your own distribution, borrow someone else’s.

When you reply to a post with 100K+ views that’s actively generating engagement, you’re placing your content inside an already-distributed conversation. X’s algorithm has already decided that thread is worth showing to hundreds of thousands of people. Your reply rides that decision. If your reply generates its own likes and engagement, the algorithm surfaces it to people who never saw the original post.

You’re essentially borrowing a megaphone from someone with a large audience — for free, with no permission required.

The Engage/Skip Framework

The key is being extremely selective. You can’t reply to everything. Replying to the wrong threads wastes your time and can actually hurt your account’s signal quality.

I developed a simple framework for every thread I evaluated:

ENGAGE when:

- Views are above 100K with a low comment-to-view ratio (under 200 comments on 100K+ views means there’s room)

- The topic connects directly to your niche — for me: CS education, degree ROI, job market mechanics, credential inflation, personal finance strategy

- The existing replies are surface-level — agreeing or disagreeing emotionally, without adding structural insight

- You can add a dimension nobody else in the thread is bringing

SKIP when:

- The thread is pure humor or emotional venting with no argument to engage

- The topic has zero connection to your niche

- Your reply would read as tone-deaf given the emotional context of the thread

- The comment count is already so high (500+) that your reply will be buried

The goal of every reply is to be the most substantive voice in the thread. Not the loudest. Not the most provocative. The most useful — to someone who is reading that thread and wants a real answer, not another reaction.

The Threads That Drove 94K Impressions

Over 48 hours I made roughly 25 targeted replies across threads in my core lanes. Here are the ones that generated the most traction:

The literacy thread (1.3M views): A post about 54% of U.S. adults reading below a 6th-grade level. My angle: literacy is the hidden variable in CS pipeline failure. You can’t debug a loop if you can’t parse the error message. Computational thinking is a literacy problem before it’s a math problem.

The degree ROI thread (142K views): A post claiming education matters. My angle: both true and exactly wrong depending on which education. A CS degree from a strong program still prints ROI. A generic business degree at $200K in debt does not. The problem isn’t education — it’s undifferentiated education with no cost discipline

.The $1M retirement thread (365K views): A post recommending anyone with $1M net worth quit their job. My angle: $1M at a 4% withdrawal rate is $40K/year pre-tax. The number that matters is after healthcare costs, sequence-of-returns risk, and whether your assets are liquid or locked in a 401k you can’t touch penalty-free. Freedom is a withdrawal strategy, not a net worth number.

The CS enrollment thread (187K views): A post noting CS majors dropped 8%, the biggest decline since 2003. My angle: every CS slump filters out the people who chose it for the salary and keeps the ones who chose it for the craft. The 2003-08 drop produced the engineers who built the smartphone era. Parents panicking about CS enrollment numbers are reading the signal backwards.

The junior dev as token arbitrage thread (670K views): A post about hiring junior developers to write simple code instead of paying AI tokens. My angle: junior devs hired as token arbitrage still need to know when the AI is wrong. The ones who survive aren’t the cheapest coders — they’re the ones who can audit what AI produces. That’s a skill ceiling, not a price point.

Notice the pattern. Every reply validates the original observation, reframes it with structural insight, and lands a specific concept — ROI, skill ceiling, Financial Runway, builder mindset — that connects to my broader thesis. No hashtags. No emojis. No self-promotion. Just signal.

The Voice Rules I Never Broke

Consistency of voice is what makes reply-mining work as a brand-building strategy rather than just an impression-farming exercise.

Every reply followed the same rules:

Validate → Reframe → Land the concept.

Never flatly agree or disagree. Always add a structural layer the original poster didn’t include.

Prose only.

No bullet points, no numbered lists, no bold text. Bullets signal content-marketing mode. Prose signals thinking-person mode. Your audience can tell the difference.

No hashtags.

Hashtags on verified accounts don’t add meaningful reach. They visually cheapen the content.

No emojis.

Unless the thread is casual and the poster uses them. Match the register of the conversation.

Under 280 characters.

Every reply. Brevity forces precision. Precision is what gets liked by strangers who owe you nothing.

No links in replies.

X suppresses reach on replies with external links. Your profile bio does the linking work. The reply just needs to make people curious enough to click your profile.

What the Numbers Actually Meant

By Tuesday night the scorecard looked like this:

- 94K impressions (up from near zero)

- 1.3K likes

- 47 bookmarks

- 25 reposts

- 135 profile visits

- 36 followers (up from 29)

The number I watched most closely was bookmarks. Bookmarks mean someone saved your content to reference later. At 36 followers, 47 bookmarks is an unusually high ratio. Those aren’t casual readers — those are people who found your content valuable enough to return to. That’s your buyer audience signaling themselves to you.

Profile visits (135) tell you how many people were curious enough about who you are to click through. Followers (7 new) tell you how many of those people liked what they saw. The conversion from profile visit to follow is where your bio and pinned content do the work.

Why I Got Suspended

Wednesday morning at 6am a scheduled thread went live — my negotiation thread about how a Substack subscriber used my 8-sentence email template to recover $20,000 in merit aid from a school widely rumored not to negotiate.

Sometime Wednesday morning, X suspended my account for inauthentic behavior.

Here’s what I believe triggered it:

a combination of signals that individually are fine but collectively match a bot pattern.

A near-zero account suddenly generating 25+ replies across multiple high-traffic threads in 48 hours. A scheduled thread posted via a third-party tool (Typefully, which is an authorized X partner). A commercial link (Gumroad) in the final tweet of that thread. Engagement metrics that were statistically anomalous for an account my size.

None of that is against X’s terms of service. All of it together, on a 36-follower account that didn’t exist a week ago, triggers an automated false positive.

I submitted an appeal immediately. I’m a Premium subscriber with an active developer API account — both of which accelerate human review. The account will be restored.

But the suspension taught me something important: X’s automated systems are calibrated for average behavior. When you execute a strategy this precisely, you become a statistical outlier.

Outliers get flagged.

What I’d Do Differently

One change: slower ramp-up in the first week.

Instead of 25 replies in 48 hours, I’d do 8 to 10 replies over the first week, then increase. The quality of each reply stays exactly the same. The velocity just doesn’t spike as sharply.

The strategy itself I’d repeat exactly. Every thread choice, every reply, every skip — the framework held up across 48 hours and dozens of threads. The engage/skip discipline is what separated the replies that generated engagement from the ones that would have been noise.

What This Means for You

If you’re a parent trying to understand how to help your kid build an audience around their work — internship projects, research, side builds — this framework applies directly.

The mistake most young people make on X is posting into the void and waiting to be discovered. Discovery doesn’t work that way on a platform with 500 million users.

What works is placing substantive, specific, non-generic insights into conversations that are already happening at scale. Being the most useful voice in a thread that someone with 100K followers started. Letting borrowed distribution do what organic reach can’t.

The builder mindset applies here, too. A consumer of X posts content and hopes the algorithm finds them. A builder of X understands how the distribution system works and operates within it deliberately.

My account will be restored.

The thread will go back live.

The 94K impressions, the 47 bookmarks, the 1.3K likes — those already happened and the data is preserved.

More importantly, the system works. I have the receipts.

The Bottom Line

The “Builder Mindset” isn’t just about beating an algorithm; it’s about navigating any high-stakes system with a plan. Whether you’re debugging a robotics sensor, growing a brand, or most importantly, navigating the high-school-to-tech-career pipeline, the mechanics are the same:

Validate, Reframe, and Land the Concept.

I’m back to work on the account restoration, but the mission remains the same.

The Engineering Dad writes about CS career strategy, college admissions ROI, and the financial mechanics of getting your kid from high school to a software engineering role without destroying your retirement.

If you want to see the exact frameworks I use to help students navigate this path (including the merit aid negotiation template mentioned in my ill-fated thread), you can find it here:

The High School CS Toolkit & Merit Aid Template

Stay systematic.

Masaru
The Engineering Dad

Have you ever been 'too efficient' for an automated system? Or are you currently navigating the CS admissions 'logic gate' with your own student?

Drop a comment below, I'm reading all of them (until the bots stop me again).

Support the Workshop: I spend my spare cycles auditing the “Source Code” of admissions so you don’t have to. If you’ve found value in these logic gates, you can buy me a coffee ☕ to help keep this workshop running and the guides open-source.

Support the Workshop

I am a Tech Dad of 3 CS grads. Lately, I have been seeing questions from anxious non-CS parents how to stand out in college admissions, and my advice has always been to become a builder. Yet, in many cases, students don’t know how to get started though my HS CS Toolkit has many easy to start projects you can begin this weekend. This article is targeted more for non-CS students who want to start building. For CS students without any prior AI supporting tools for coding, this may be a good intro material.

What is vibe coding? It is a term used for coding primarily through natural language and intent, so you don’t have to learn Python or C++ specific syntax to get started. This is important because in many cases, students get hang up on progressing because the initial set up takes too long and get discouraged to continue. We want to make sure the barrier to entry is low for students.

To help you follow along with today’s strategy, grab your CS Toolkit copy here before we dive into the breakdown.
📥 Download the CS Toolkit

Here’s the setup I used, and why I’m teaching students to ship this way before they write a single line of production code.

I don’t pay for AI coding tools anymore. Not because I stopped using them, I use them more than ever, but because I found a setup that costs nothing and teaches you more than any subscription workflow does.

Here’s what I built: Claude Code, Anthropic’s agentic CLI, pointed at OpenRouter, running on Nvidia’s free Nemotron 3 super 120b a12b model.

Zero dollars a month.

No Debt Anchor.

My students can experiment on a Friday night without me watching a meter tick up.

It took me about 15 minutes to wire up. The part that surprised me wasn’t how easy it was, it was how legitimate the workflow feels once it’s running.

What Claude Code actually is

This isn’t a chatbot in a browser tab. Claude Code runs in your terminal, reads your file system, writes files, runs commands, and iterates — all inside a single conversation thread. Think of it as an agent sitting inside your repo. You describe what you want. It scaffolds. You review. You push to GitHub when it’s done.

Normally this requires paying for Anthropic API credits. But Claude Code accepts a custom base URL, which means you can point it at any OpenAI-compatible endpoint. It is basically the universal remote for AI models. OpenRouter is exactly that, a unified API layer that routes to dozens of models, including free ones, behind one interface.

How to set it up

These parts assume you have some familiarity with command line interface, like a terminal on Mac. If you don’t, I will leave it as your own learning practice. There are a lot of YouTube videos showing how to use Mac terminal or Windows Powershell.

Install the CLI first — you need Node 18 or higher:

npm install -g @anthropic-ai/claude-code

Create a free account at openrouter.ai and generate an API key. You don’t need a credit card for the free models. Find the identifier for Nvidia Nemotron in the model list, something like nvidia/nemotron-3-super-120b-a12b:free

Then set two environment variables in your shell config:

export ANTHROPIC_BASE_URL=https://openrouter.ai/api/
export ANTHROPIC_API_KEY=your_key_here

Launch with:

claude --model nvidia/nemotron-3-super-120b-a12b:free

Navigate to your project folder first. From there, you’re in the loop.

Note that I am intentionally giving you a minimal instruction. Your initial job is to get the claude code running. If successful, you may see something like this. Say hi and see if it responds back.

What I actually built

I started with the simplest thing I could think of: a tic-tac-toe game in HTML.

That’s it. No database, no API, no dependencies. Just a single file that runs in a browser. I opened the terminal, navigated to an empty folder, and typed: create a tic tac toe game in a single HTML file with basic styling.

You notice there was an error. That’s because I had created the game yesterday for initial testing before writing this article, and found the file already existing. So I later asked to save the file as ttt.html and it was successful. If you encounter these errors, you do learn what may have happened. That’s another advantage of doing the actual hands-on build session like this. Debugging the AI is where the actual learning truly happens.

It wrote the whole thing, board layout, turn logic, win detection, reset button. I opened the file in Chrome. It worked!

Then I did the part that actually teaches you something. I asked it to audit its own output. What’s brittle here? What breaks if I add a feature? It came back with real answers: the winning conditional array is fixed at 3x3, and board initialization loops hard coded 9 times (to basically reset the whole board space one by one clearing any existing value. This would break if you try to change the board size to 4x4 or larger. I asked it to fix both. It did. I read every line of the diff.

By the time I ran git push, I hadn’t just generated a file. I had navigated a complete build cycle , prompt → scaffold → audit → iterate → ship, without leaving the terminal or opening a browser tab to ask a chatbot for help.

That audit loop is the discipline that makes this workflow real. Free models move fast and skip edge cases. You have to ask them to check their own work. Once you build that habit, it transfers to every project after this one.

Why this is the right way to learn

I have spent over a decade coaching FIRST robotics, FLL, FTC, FRC, and watching kids hit the same wall. It’s never syntax. It’s never logic. It’s the gap between having an idea and seeing something work on the screen. That gap kills momentum faster than any hard concept does.

This stack closes it. You still write prompts. You still debug. You still own the architecture. But you’re doing it on top of a working scaffold instead of a blinking cursor in an empty file, and that changes how fast you build real intuition.

This is the Institutional Moat move I wish I’d had when my kids were first learning to ship. It’s not about saving $20. It’s about removing every excuse to wait before you start building.

Set it up this weekend. Build something small. Push it to GitHub.

Drop a comment and let me know what you are building.

Support the Workshop: I spend my spare cycles auditing the “Source Code” of admissions so you don’t have to. If you’ve found value in these logic gates, you can buy me a coffee ☕ to help keep this workshop running and the guides open-source.

Support the Workshop