I started programming in my AP Computer Science class in high school in 2018. I went to a public school in the suburbs, so our teacher was the Algebra II teacher who had a last minute class tacked on to her schedule because it was vaguely math-y. As a result, I learned the art of programming in a way that was, until recently, the norm: frantic google searches, copying StackOverflow, and staring at Eclipse and the Java textbook and praying for my code to run. It was gritty and scrappy and I learned by writing code in pencil (the horror!) from docstrings in the back of the book. I was by no means an expert programmer at this point, but I vaguely understood what code was and how to test its correctness.
Then I was fortunate enough to be a CS major at Cornell, and I received a genuinely world class technical education that encompassed both the theory and math underpinning software engineering as well as got my hands dirty with projects and internships. I spent months of my life (that I will never get back) in the Clark Hall Physics Library poring over my Discrete Structures and Algo homework and formatting it in LaTeX by hand. I learned what it means to write good, idiomatic code from Professor Clarkson in his functional programming class. I joined a project team, AI-Learners, and interned at WeWork, and wrote real user-facing software, albeit in a training environment, that had stakeholders and needed some proof of correctness.
Fall of senior year, ChatGPT released. I do not need to explain to you what ChatGPT is, but I can shed some light on what it was to us, at least to us at the time. It was, to be honest: just fine. I had been sufficiently educated after 4 years of programming that in November 2022, I can confidently say that I was better than ChatGPT. Now, don't get me wrong, if high-school me had access to this, his Java course would have been made significantly easier. But at the time it was making frequent errors and hallucinating in my Analytical Mechanics problem sets and graphics coding projects.
Fast forward to today. OpenAI released their Astra model this week, and they announced that they had an internal model that found a solution to the Navier-Stokes millennium problem. I use tools like Codex and Claude Code every day to generate code, and spend a large portion of my time reviewing agentic output. These models are genuinely better programmers than me— that's not a controversial take nor am I afraid to admit it (they are also probably more expensive than me, too. OpenAI spent millions of dollars on that Navier-Stokes problem, for example).
So I started thinking. What was all my education for? What am I for?
Then my favorite video game got a remake.
I am an undying fan of The Legend of Zelda. I have been playing these games since I was little— starting with Twilight Princess on the Wii (I'm not that old). I've played basically all the entries in the series, save for a few CD-i and DS games. One of my favorites, frequently lauded as one of if not the greatest game ever made, is Ocarina of Time.
In Ocarina, you start the game as Link during his childhood. Link is tasked with purifying the inside of the Great Deku Tree, and then is sent off to Princess Zelda, who tells Link of the evil of Ganondorf and sends him off to collect the three... these details are not that important. Suffice it to say that Link (and you, the player) are swept up in an adventure that spans the kingdom.
At a certain point, Link has unlocked the door in the Temple of Time that leads to the Master Sword. The Master Sword is known in-universe as the "blade of evil's bane" and "the sword that seals the darkness" (it's so fucking cool). It is a divine weapon, and is literally programmed as stronger in-game than Link's childhood sword. Link pulls the Master Sword from its sheath and, after some spoiler-y events, awakens 7 years later wielding his new weapon.
Link physically cannot wield this weapon as a child. He has to earn it, through trials by fire (and, infamously, water) and overcoming puzzles and challenges that would otherwise stop him.
As I was watching the Ocarina of Time remake trailer at my desk, I was thinking about this. In almost all the other games, obtaining the Master Sword is itself a journey. In some, if Link tries before he's ready, it's a game over. Link and the player need a certain amount of experience before being able to wield the weapon.
On the other hand, my non-technical friends from high school are making fantasy football plugins with Claude Code.
I am not here to gatekeep— seriously. I do not think that software engineers are in peril like many viral tweets say; if they were, then I would not be in so many architecture meetings every day.
But it really does beg the question: if all you need to do is pick up the sword and you're suddenly a world-class programmer, then where is engineering going? For one thing, I don't think I, or any hiring manager for an engineering role, would hire my high-school friends if they put these side projects on their CVs. If young Link woke up one day and had the Master Sword dropped at his feet— saving Zelda isn't trivial all of a sudden. Good software, especially software that needs to be secure, like online banking, electronic voting, or the Odyssey IMAX ticket queue, is borne of thousands of little decisions that are made easier the more experience you have in the industry.
I was working on a pretty simple python script and using Fable 5.1 to generate it. It just needed to make an API request. I saw that it imported os fine, but then it added this snippet:
def _read_env_file(path: str, key: str) -> "str | None":
"""Pull a single KEY=value out of a .env file, without importing python-dotenv."""
try:
with open(path) as f:
for line in f:
line = line.strip()
if not line or line.startswith("#") or "=" not in line:
continue
k, _, v = line.partition("=")
if k.strip() == key:
return v.strip().strip('"').strip("'")
except FileNotFoundError:
return None
return None
def _resolve_token(token_env: str, token_cmd: "str | None", env_file: str) -> "str | None":
"""Read the admin token from a --token-cmd (e.g. Keychain), the environment, or a .env file.
Never printed. Returns None so --dry-run works with no credential present.
"""
if token_cmd:
out = subprocess.run(token_cmd, shell=True, capture_output=True, text=True)
if out.returncode != 0:
raise SystemExit(f"--token-cmd failed: {out.stderr.strip()}")
return out.stdout.strip()
return os.environ.get(token_env) or _read_env_file(env_file, token_env)
A pretty good programmer can understand what it's doing. A pretty good engineer should also tell you why it shouldn't be doing that.
The Master Sword does not intrinsically make Link a better hero. I don't think Claude Code intrinsically makes me a better engineer. It still empowers me hundredfold, and allows me to tackle more problems day to day. But the engineer that it's empowering is me. And if I give up on learning, then I'm still going to eventually stagnate, even as the models grow in capability.
At least until someone makes the Biggoron Sword, then we can talk.
I'll be chained to my couch playing the Ocarina of Time remake this November. Until then, you can reach me via email or LinkedIn. Happy engineering.