Paths/CS

Next cohort starts Jan 2027 · Virtual · 2 hours a week
PATHS / Computer Science
$ git push origin main
SELECT * FROM students;
def ship(idea): return reality
// Status: internship-ready
Computer Science · Grades 6 – 8 · Virtual

In 3 years,
they're internship‑ready.

Most middle school CS programs teach syntax. We graduate builders — students who ship real software, work from real specs, and walk into real internships with portfolios that already speak for them.

Live on Zoom. See real student projects and ask anything — no commitment.

Live & virtual join from anywhere
2 hours of class a week
3-year structured journey
Real portfolio at graduation
Our Approach

Knowing how to code isn't the same as being able to ship a working product.

Plenty of bright middle schoolers can write a Python script. Very few can deliver a working application to someone who needs it. That gap is what derails students later, in internship searches and tech interviews — and it's the gap PATHS is built to close.

The PATHS Approach

We build engineers, not just exam-takers — though our engineers do excel on exams, too.

  • They build real projects, deployed somewhere real
  • Professional tooling is daily reflex by 8th grade
  • Students work from written specs and ask clarifying questions
  • Code reviews, status updates, and documentation are the norm
  • AI assistants are used deliberately — with comprehension checks
  • Graduates can be handed a problem and trusted to ship a solution
The Three-Year Journey

From first line of code to first real internship.

Each year compounds on the last. Skills built in Grade 6 are still load-bearing in the Grade 8 capstone — which is how professional engineering works.

01 · STAGE ONE
Grade 6

Foundations & Data Fluency

Students move from blocks to a real programming language. They learn to think with data, work from the command line, and adopt the professional habits that separate engineers from people who took a coding class.

Python Data & Charts Version Control Scientific Method
02 · STAGE TWO
Grade 7

Shipping Real Applications

The transformative year. Students build, deploy, and document complete web applications — with databases, real users, and live URLs. They learn to work from a written specification, review each other's code, and use AI the way professionals do.

Web Development Databases & SQL Deployment Code Review
03 · STAGE THREE
Grade 8

Rigor, AI, & the Capstone

Students level up with object-oriented design and algorithmic thinking, ground themselves in machine learning, and keep using AI tools the way professionals do. The year ends with a capstone project built to professional standards — the artifact that opens the door to real internships in high school.

OOP & Algorithms AI / ML Foundations Capstone Project Portfolio Piece
What Makes This Different

The professional habits we build — on purpose, every week.

These aren't topics we cover once. They're reflexes built across years. By the time PATHS students reach high school, they don't have to think about any of this — which is exactly why employers notice.

Version control as reflex

Every line of code lives in a real repository, with real commits, from week one. Many college freshmen still struggle with this.

Shipping, not just building

If it only runs on the student's laptop, it doesn't count. Projects get deployed where someone else can actually use them.

Specs & clarifying questions

Students learn to read a written spec, ask the right questions, and confirm scope before writing code.

Reading code, not just writing it

Professional engineering involves a lot of reading. Our students do regular peer code reviews — reading each other's work and leaving real comments.

Deliberate AI usage

We don't ban AI tools — we teach students to use them the way working engineers do, with comprehension checks that prevent dependency.

Professional communication

Status updates in five sentences. Bug reports with reproduction steps. Emails that don't start with "hey." Writing is engineering.

Estimation & scope

Students learn to estimate how long things take, track actual vs. estimated time, and reflect on why their estimates were off.

Debugging as a skill

Real debuggers, reading stack traces, reproducing bugs before fixing them — the skill that separates "I know syntax" from "I can solve problems."

The Defining Project

The Capstone.

The project that defines our students — and the artifact that gets them into real internships in high school.

~/paths/capstone
$ ./build-engineer.sh

A serious build. A serious deliverable. A real portfolio piece.

Every PATHS student finishes middle school with a deployed software project built to professional standards — a written spec, weekly progress check-ins, real infrastructure, and a live demo. For some students the client is a real teacher, school program, or nonprofit. For others, an instructor plays that role. Either way, the experience is the same: it's the story they walk into every future interview with.

Built to a written specification

Deployed to a real URL anyone can visit

Weekly status updates & check-ins

Live demo & complete documentation

In 3 Years

What our students look like in 3 years.

Not someday. Not "eventually." In 3 years.

Ready for real internships

Not shadowing. Actual work for nonprofits, small businesses, or research labs — in 9th and 10th grade.

A real portfolio

Multiple deployed projects with live URLs. A capstone built to professional standards. Code anyone can read on GitHub.

AP CS A — effortless

Years of object-oriented work in advance. They're not learning Java for the test — they're already fluent.

Independent problem solving

Hand them an unfamiliar problem and they'll figure it out — the single skill every internship coordinator looks for.

Adult-level communication

Writes a clear status update. Sends a professional email. Asks a manager the right clarifying questions.

Confidence that's earned

The quiet confidence of a student who's already shipped real software. It shows up in interviews. It shows up everywhere.

Proof, Not Promises

Our students' work is already live.

The habits PATHS builds in middle school are the same ones our high school interns use on real projects for real organizations.

PAST INTERNSHIP PROJECT

City of Charlotte Open Data Portal

Designed by Thinking Feet interns. A public site that residents, researchers, and city staff use to explore Charlotte's open data — real users, real stakes, live on the web.

Visit data.charlottenc.gov

Thank you for giving my child a chance to work on something meaningful.

— Thinking Feet parent

It's great to see my son using what he is learning to benefit the community.

— Thinking Feet parent
ALUMNI · COLLEGE

Studying Computer Science / Computer Engineering / Electrical Engineering at

University of Pennsylvania UNC Chapel Hill Georgia Tech UIUC NYU Duke MIT
ALUMNI · CAREERS

Internships & full-time roles at

Meta Amazon Splunk Silicon Valley startups
Next Steps

How to get started

STEP 1

Join a free info session

A 45-minute live Zoom session. See real student projects, learn how the three years fit together, and ask questions.

Register on Zoom →
STEP 2

Book a free consult

A 15-minute call to talk about your child and see whether PATHS is the right fit.

Pick a time →
STEP 3

Join the January cohort

Reserve a seat in the next cohort, starting Jan 2027. Live, virtual classes, 2 hours a week.

Ready to Start?

Give your child the 3-year head start.

PATHS is a serious, long-term commitment for serious students. If that sounds like your child, start with a free info session.

Copyright © 2026 Thinking Feet, LLC. All rights reserved.