I Still Don’t Really Know JSX. And I Don't Think It Matters.
I built a production-grade React app—and still don’t fully understand JSX. In the AI-assisted era, syntax mastery matters less than system design. You’re not the coder anymore. You’re the architect. The real skill? Knowing what to ask, how to judge, and when the output doesn’t fit.
I just shipped a complex React application. It’s data-driven, theme-aware, and type-safe. It runs cleanly in strict mode and was built to scale.
And I still don’t really know how JSX works. Not the way a traditional frontend dev does. I couldn’t walk you through the Babel transform pipeline. I don’t have the self-closing tag rules memorized. Honestly, I didn’t write most of the boilerplate anyway—my AI assistant did.
At first, I wondered: Should I feel like a fraud?
I don’t think so. Because my job wasn’t to master syntax.
It was to design the system.
You’re Not Here to Memorize—You’re Here to Design
I may not know JSX deeply. But I do understand:
- What this app is supposed to do—its purpose, boundaries, and interfaces.
- What makes it maintainable—composition, abstraction, and state discipline.
- What guardrails are needed—how to encode constraints in TypeScript.
- What ‘wrong’ looks like—when the AI gives me code that’s technically fine but architecturally brittle.
That’s not classic frontend expertise. That’s systems thinking. My value wasn’t in the keystrokes—I brought the map.
The Lead Architect Mindset
This feels familiar. In enterprise work, the lead architect rarely:
- Hand-writes every query.
- Authors every test.
- Stays fluent in every YAML schema.
Instead, they:
- Define the principles.
- Enforce the constraints.
- Interrogate the output.
Same here. When building with AI, I’m still doing the architect’s job—just in a compressed loop between me and my assistant.
The AI is fast, capable, and obedient. But it needs direction. It needs me to notice when a proposed solution will scale—and when it’ll rot in two sprints.
AI Isn’t Replacing Engineers—It’s Replacing the Dev Team
Software used to be a team sport. Architect, developer, reviewer, QA, DevOps.
Now? I’m often solo with a fast-reacting partner in the loop. But I’m still doing all those jobs—just abstracted up a level.
- I am the Architect, defining the patterns and guardrails.
- I am the Lead Dev, delegating tactical work to the AI.
- I am the Reviewer, catching brittle code before it spreads.
- I am the QA, directing validation tests and edge case coverage.
I don’t need to know everything. I need to know how to lead the team—even if it’s just me and a machine.
The Wrong Question Is “Do I Know Enough?”
If you’re building with AI and wondering:
“Am I a real engineer if I don’t know what’s happening under the hood?”
That’s not the right question.
Ask instead:
- “Did I define the ‘why’ clearly?”
(Can the assistant follow my intent without hallucinating?) - “Did I audit the ‘how’ wisely?”
(Can I detect when the code works, but the design is off?) - “Does this solution compound or collapse over time?”
(Am I building leverage, or layering fragility?)
If you can answer those questions, you're already doing the real job. You’re not memorizing syntax. You’re steering systems.
And that’s the only expertise that matters now.
