Software Engineering — What the Job Actually Is
Most real engineering happens like this — around a table, laptops open, figuring it out together.
People think software engineering is writing code. Writing code is maybe 20% of it. The job is managing complexity over time — building systems that other people (including future-you) can understand, change, and trust. Here's how I think about the craft.
The real skill: taming complexity
Any feature can be built a hundred ways. The senior move is picking the version that will be cheapest to live with — easy to read, easy to change, hard to break. Concretely:
- Write code for the reader, not the compiler. Names, structure, and boundaries matter more than cleverness. The next person to touch this is the audience.
- Make the change easy, then make the easy change (Kent Beck). Refactor first so the feature drops in cleanly, instead of jamming it into an awkward shape.
- Delete more than you add. The best PRs often remove code. Less surface area, fewer bugs.
The fundamentals that don't go out of date
Frameworks churn; these don't:
- Data structures & algorithms — not to grind LeetCode forever, but to have intuition for cost. Knowing when a hash map turns an O(n²) loop into O(n) is daily-useful.
- How the machine works — memory, the network, the filesystem, latency numbers. Most "mysterious" bugs are just a leaky abstraction you didn't look under.
- Version control (git) fluency — branching, rebasing, reading history. This is how teams actually collaborate.
- Testing — enough to change code without fear. Tests are a design tool, not a chore.
- Debugging — forming a hypothesis, checking it, narrowing the space. The single most transferable skill.
Design before you code. The whiteboard is where the expensive mistakes get caught cheaply.
How to actually get good
- Ship real things. A deployed side project teaches more than ten tutorials — you hit deployment, auth, edge cases, and the boring 80% that tutorials skip.
- Read code better than yours. Clone a well-run open-source repo and study how they structure things.
- Get your work reviewed and review others'. Code review is where taste transfers.
Mentors and peers accelerate everything. Taste is caught, not taught.
4. Write. Explaining a system in prose exposes the parts you don't actually understand.
Career notes for international students
The craft is universal, but the game has a US-immigration overlay (OPT/CPT): target STEM-designated degrees and E-Verify employers so the STEM OPT extension is on the table. Big companies handle visas routinely; many startups don't — factor that into where you apply.
Where this connects
AI engineering is a specialization built on top of solid software engineering — the people who struggle with AI systems are usually the ones who skipped the fundamentals. And if you go the startup route, engineering judgment is what lets a tiny team move fast enough to be worth funding.
Related: Ai Engineering · Seed Funding · Opt Cpt Application
