Einstein, Salesforce Certs, and the Agentic Era
There's a story about Einstein, probably apocryphal, where someone asks him for the speed of sound. He doesn't know it. When the guy presses him about why a man of his intellect can't recall such a basic figure, Einstein says: "I do not carry such information in my mind since it is readily available in books."
That line gets quoted a lot. It's about to become the most quoted line in the Salesforce ecosystem, and most people are going to use it wrong.
The lazy take
The lazy take goes like this. AI agents can look up anything. They can write SOQL, generate Apex, configure flows, and read documentation faster than any human. So certifications, those exhaustive memorization marathons about field types and governor limits and sharing rules, are obsolete. Why memorize what an agent can fetch?
You're already seeing this on LinkedIn. "Don't waste time on certs. Just learn to prompt." The argument treats the cert like a trivia exam Einstein would've refused to study for.
The problem is that certs were never really trivia exams. And Einstein wasn't arguing against knowing things.
What Einstein was actually saying
Read the line again. He's not saying knowledge is worthless. He's saying that for any specific fact you need, the lookup cost is low enough that hoarding it in your head is bad allocation. The implicit assumption, the part everyone skips, is that you already have the framework to know which fact to look up, what it means when you find it, and whether the answer you got is right.
Einstein could afford not to memorize the speed of sound because he understood waves and mediums and propagation deeply enough that the number itself was the least interesting part. Hand him a wrong answer from a book and he'd catch it. Ask him a follow-up and he'd reason through it. The lookup was a convenience sitting on top of a foundation that wasn't optional.
That's the lesson. And it maps directly onto where we are with Salesforce right now.
Certs are not the trivia. The trivia is the side effect.
The Platform Developer I exam asks you about governor limits. The Sharing and Visibility Architect exam asks you about implicit sharing behavior. An agent can answer either question faster than you can.
But here's what the cert actually does to your brain when you study for it. You build a model of the platform. You internalize that Salesforce is a multi-tenant system, that governor limits exist for a reason, that sharing is a layered model with predictable failure modes, that triggers fire in a specific order for non-arbitrary reasons. You stop seeing Salesforce as a pile of features and start seeing it as a system with a shape.
That model is the framework. And the framework is what lets you tell when an agent is about to ship something dangerous.
The agentic era raises the bar, not lowers it
When a developer writes bad Apex, they hit a governor limit, see the error, and learn. The feedback loop is tight. The blast radius is one developer.
When an agent writes bad Apex at scale, across flows and automations and integrations and generated triggers and scheduled jobs, the failure mode is different. It's plausible-looking code that compiles, deploys, runs fine in a sandbox, and quietly accumulates risk that surfaces in production three months later when someone runs a bulk operation. The agent used SOQL inside a loop because it pattern-matched a tutorial. The agent generated a flow that bypasses sharing rules because the prompt didn't specify the user context. The agent built an integration that works fine until it hits the daily API limit on a busy Monday morning.
The person who catches that is the person with the framework. The person without it ships it.
This is why "certs are dead" has it backwards. When an agent can produce a thousand lines of Apex in thirty seconds, the bottleneck stops being typing speed or syntax recall. The bottleneck becomes judgment. The ability to look at generated work and know, in your gut, that something is off. That gut comes from the model in your head, and that model comes from doing the work the cert forces you to do.
What changes, what doesn't
Some things do change. Memorizing every standard object's API name probably isn't the highest-leverage use of your time anymore. Drilling on the exact syntax of a Database.Stateful batch class? Let the agent generate it.
But the conceptual content of the certs is now more valuable, not less. When to use a flow versus an Apex trigger. What implicit sharing actually does. Why a Lightning Web Component re-renders. How the platform handles bulk DML. What the Einstein Trust Layer is and isn't. How managed packages namespace their metadata. Every one of those concepts is a place where an agent can produce convincing output that's subtly wrong, and you need to be the one who notices.
The Agentforce Specialist cert is a good example. The surface content is how to configure an agent in Salesforce. The underlying content is how to reason about an autonomous system operating inside a CRM with sharing rules, audit requirements, and bounded tool access. The second thing is the actual skill. The cert is the forcing function that makes you learn it.
What about the bootcamps?
The same logic applies one tier up. Remember the twelve-week coding bootcamps? Pay fifteen grand, learn JavaScript or Python or Ruby on Rails, walk out a junior developer. There was a whole industry of them, and a reasonable question right now is whether they still make sense. If an AI can write the code, why pay to learn the language?
The answer depends entirely on what the bootcamp was actually teaching.
Some bootcamps taught syntax. How to write a for loop. How to make a fetch request. How to wire up a CRUD app from a tutorial. Those bootcamps were always selling the wrong thing, and AI just made it obvious. If your value proposition was "we'll teach you to type the magic words," the magic words are now free. That product is over.
But the good bootcamps weren't really teaching JavaScript. They were teaching you to think like a programmer using JavaScript as the medium. How to decompose a problem. How to reason about state. How to read an error message and form a hypothesis. How to debug something when the obvious explanation is wrong. The language was the vehicle, not the destination, and the people who came out of those programs could pick up a second language in a weekend because they'd actually learned the underlying thing.
Those skills got more valuable, not less.
Here's the trap. You can absolutely vibe-code your way to a working app right now without knowing what a closure is or why your component is re-rendering. The agent will get you to something that runs. The problem shows up later, when something breaks in a way the agent can't fix because the agent doesn't actually know what's wrong either. It's just guessing at patterns. And if you don't know the language well enough to read what it produced, you can't tell whether its guess is right. You're stuck. Two people staring at the same broken code, neither of them sure what it does.
The language matters. Not because you need to write it from scratch, but because you need to read it critically. Same as the cert. Same as Einstein.
The bootcamp question isn't really "is learning the language still necessary." It's "are you learning the language, or are you learning how to think." If a program is teaching the second thing using the first as the vehicle, it's worth the money. If it's teaching syntax drills and tutorial reproductions, the agent already does that for free and does it better.
The real Einstein move
If Einstein were a Salesforce architect today, he wouldn't memorize every governor limit. He'd absolutely let an agent pull the current numbers when he needed them. But he'd know, cold, why governor limits exist, what category of failure they prevent, and which architectural patterns make them dangerous. He'd know the shape of the system well enough that when an agent proposed a solution, he could tell within a few seconds whether it was right.
That's the move. Not "skip the framework because lookup is cheap." It's "build the framework so deeply that lookup is all you need."
Certs aren't trivia. They're the scaffolding that makes the lookup work.
In the agentic era, the people who skipped the scaffolding are going to ship a lot of confident-looking nonsense. The people who built it are going to be the ones cleaning it up.