Prabhash Jha

Posted on Sep 23 Originally published at prabhashjha.com

The Skills That Actually Matter in the Age of AI

#founder #lessons

The standard advice for surviving AI is "learn to code". It's close to backwards.

Code is text. It has a machine-checkable output. It compiles or it doesn't. The tests pass or they don't. The type checker screams or stays quiet. And there's an enormous public corpus of it, written in public, with the answers attached. Text in, verifiable result out, mountains of training data. That combination describes exactly the shape of work machines get good at fastest. Telling someone to learn programming because it's safe from automation is like telling someone in 1995 to become a typist because computers were coming.

That doesn't mean programming is a bad thing to learn. It's a superb way to build precise thinking. Someone has to direct the machines. What's wrong is the reason people give for learning it, and the wrong reason leads you to the wrong version of the skill. Memorising syntax instead of learning to specify a system, argue about trade-offs, and own the outcome when it breaks in production at 2am.

So the real question isn't "which job title survives?" It's narrower and more useful: which parts of my work have a checkable answer, and which parts require someone to carry the consequence of being wrong? The first part is getting cheap. The second part is where your income is going to come from.

Why "learn to code to stay safe from AI" gets it backwards

Work automates in a predictable order. Difficulty isn't the variable people think it is. Chess fell before laundry-folding. Radiology image classification advanced faster than plumbing. The pattern isn't "easy tasks first". It's "verifiable tasks first".

Three conditions make a task cheap for a machine to learn:

The output can be scored automatically. A test suite, a compiler, a scoring function, a right answer at the back of the book. Without a signal, there's nothing to train against.
The input and output are both text or pixels. No physical world, no permissions, no meeting three people to find out why the last attempt failed.
The corpus is public and huge. Millions of examples, freely scraped, with the reasoning included.

Software engineering ticks all three harder than almost any other white-collar craft. Most legal drafting ticks two. Financial modelling ticks two and a half. Managing a supplier relationship in Chandni Chowk ticks none.

Honestly, the corollary is uncomfortable. Some of the most expensive credentials in India, the ones families optimised entire childhoods around, sit in the highest-verifiability zone. An entry-level services role whose value is "convert a written spec into working code, correctly, on time" is defined by the exact loop a model closes cheaply. Meanwhile a diagnostic electrician who works out why an old building trips its breaker only on humid evenings has none of the three conditions working against them.

Task	Auto-scoreable output?	Purely text/pixels?	Large public corpus?	Automation pressure
Writing a CRUD API endpoint	Yes (tests, compiler)	Yes	Yes	Very high
Summarising a 40-page report	Partly	Yes	Yes	Very high
Building a campaign forecast model	Partly (backtest)	Yes	Some	High
Deciding which of two strategies to fund	No	No	No	Low
Telling a client their brief is wrong	No	No	No	Very low
Diagnosing an intermittent electrical fault	No (world is the test)	No	No	Very low
Signing off on a regulated filing	No (liability attaches)	Partly	No	Very low

Read the last column as "how fast the price of this falls", not "does this disappear". Endpoints still get written. They're just no longer what you get paid for.

What actually protects a skill from automation

Apply one test to any task you do: if it goes wrong, who gets the phone call?

If the answer is "nobody, we just regenerate it", the task is already commoditised whether or not your employer has noticed yet. If the answer is a named human who loses money, standing or a licence, that task is protected. Not by difficulty. By the fact that a model can't be a defendant, can't be fired, and can't be trusted by a counterparty who wants someone to blame.

Five things pass that test. They're the spine of the rest of this piece.

Accountability. Being the person whose name is on the decision.
Judgement under ambiguity. Choosing when the data is incomplete and will stay incomplete.
Relationships and trust. Access, reputation, the benefit of the doubt.
Physical skill in an unstructured world. Hands, sites, machines, other people's premises.
Taste. Knowing which of ten adequate options is the right one, and why.

The original version of this argument is the one worth keeping. As execution gets cheap, the bottleneck moves to deciding what to make, why, and whether it's any good. Judgement, taste and communication become the scarce inputs. What follows is how to build each one on purpose rather than hoping it accumulates.

Accountability is the skill people are actually paid for

Most senior salaries aren't paid for output. They're paid for someone to hold the bag. A model can propose the budget reallocation. It can't be the person who tells the board why the quarter missed.

You build accountability the same way you build credit. Take small amounts of it early and never default. Concretely:

Put your name on forecasts, in writing, before the result. "I expect this to land between X and Y by the 20th." Then publish the comparison. Include the misses. Two quarters of that is worth more than any certificate.
Own the number, not the task. "I ran the campaign" is a task. "I own blended CAC for this line" is accountability. Ask to be measured on an outcome even when nobody offers.
Escalate early and specifically. The people who become trusted are the ones who say "this will miss by 15%, here are the two options" on day three. Not the ones who say nothing until day thirty.
Never launder a decision through the tool. "The model said so" is the fastest way to destroy the thing you're trying to build.

Judgement under ambiguity, and how to build it deliberately

Judgement isn't opinion. It's the ability to make a defensible call when the information is missing and will stay missing, and to say what would change your mind.

The reason models struggle here isn't intelligence. Ambiguity has no ground truth to train on. Two competent people can look at the same numbers and reasonably choose differently, because they're weighting risks the data doesn't contain. Cash runway. A supplier's temper. A regulator's mood. A co-founder's tolerance for a bad quarter.

Build it like this:

Keep a decision log. One line per real decision. What you chose, what you expected, what would prove you wrong, review date. Nothing improves judgement faster than being confronted with your own past reasoning.
Write the pre-mortem. Before committing, write the paragraph explaining why this failed, dated six months out. If you can't write it, you don't understand the decision.
Force the reversibility question. Is this a one-way door or a two-way door? Two-way doors deserve speed, not analysis. One-way doors deserve the opposite. Most people apply exactly the wrong effort to each.
Use AI as the opposing counsel, not the advocate. Ask it to make the strongest case against your plan. Then check whether its objections survive contact with facts you know and it doesn't.

Relationships and trust: why the network is the real moat

A model can draft the email. It can't be the reason someone replies.

Trust is the one asset that appreciates while everything around it deflates. When drafting costs nothing, inboxes fill with competent, well-formatted, entirely ignorable messages. The marginal value of being known goes up. Distribution beats production. And distribution, at the individual level, is relationships.

This is buildable and most people build it wrong. They network when they need something. The compounding version is narrow and boring. Pick fifteen to thirty people whose work you genuinely find interesting. Be useful to them at a low, consistent rate. An introduction. A document. A heads-up on something they were about to get wrong. Don't ask for anything for a year. The register you're creating is "this person is worth knowing", which is not a favour you can call in but an asset that pays out in unplanned ways.

Publishing is the leveraged version of the same thing. Writing in public about how you actually work compounds into inbound trust. People arrive already convinced, which is the most expensive step in any sale. The mechanics of that are covered in networking: the one lesson I wish I had learned earlier and how to grow your brand using digital channels.

Physical skill and the world that resists text

The safest work in the next decade is disproportionately work that happens in a place, with hands, in conditions that vary. Not because it's hard to reason about. Because it's expensive to instrument. Every physical task requires a robot, a supply chain, service infrastructure and someone to accept liability when it drops something on a customer's floor. Text costs a few paise per thousand tokens.

This matters for two groups. If you already do physical work, the protected part is diagnosis and site judgement, not the routine execution. Become the person who works out why, not just the person who fits the part. If you're a knowledge worker, the lesson isn't "retrain as a plumber". It's that any part of your job which involves being physically present, running a shoot, walking a warehouse, sitting across from a distributor, is worth more per hour than the part you do at a keyboard. Shift your time accordingly.

Taste is the only defence against infinite mediocre output

When anyone can produce forty variants in a minute, the scarce skill is picking. Taste is the compressed memory of a thousand comparisons. Knowing that the second headline is better and being able to say why in one sentence that generalises.

It's trainable, and the method is unglamorous. Consume a lot of work in your field with the intent to judge it. Write down the judgement. Then check it against reality. In advertising that means keeping a swipe file with a note attached to every entry. Not "nice ad" but "this works because the objection is handled in the first four words". Then run things and find out how often you were right. Taste that has never been marked against an outcome is just preference.

The AI-era version of taste has a second component. Knowing what not to make. Cheap production creates enormous pressure to publish more, and more of the same thing is how a brand becomes invisible. Someone has to say no forty times an hour.

Directing AI without becoming dependent on it

Briefing, reviewing and combining model outputs is now a core skill in itself. The failure mode isn't using it too much. It's using it in the zone where you can't check the answer.

The rule I'd hold to: use AI heavily where you can verify, cautiously where you can only sample, and not at all where you cannot tell right from wrong. In a domain where you have no expertise, the output isn't knowledge. It's a confident-sounding claim you are unable to audit. And you'll find out it was wrong at the worst possible time. Why ChatGPT gives wrong answers covers the failure mechanics; how to actually use ChatGPT and Claude for real work covers the working patterns.

Two habits keep dependency in check. First, keep one hard skill you still practise unassisted. Write one thing a week with no tool open. Or build one thing by hand. Second, never let the tool make the choice. Let it make the options. The moment you find yourself unable to explain why you shipped what you shipped, you've handed over the part that was yours.

A worked example: what accountability is worth in rupees

Abstractions don't move people. So here is the arithmetic on why "someone who checks" is a paid role.

Take an account running ₹25,000 a day in media spend with a target cost per acquisition of ₹600. An automated bidding change, or an AI-suggested reallocation nobody reviewed, pushes the actual CPA to ₹1,200. The spend continues either way. Only the efficiency drops.

Over three days, ₹75,000 is spent:

At the target CPA of ₹600, ₹75,000 should buy 125 conversions.
At the actual CPA of ₹1,200, it buys 62.5 conversions.
Value delivered at target rates: 62.5 × ₹600 = ₹37,500.
Wasted spend: ₹75,000 − ₹37,500 = ₹37,500.

Now suppose someone catches it on day one instead of day three. Only ₹25,000 has been spent at the bad rate. 20.83 conversions instead of 41.67. So the waste is ₹25,000 − (20.83 × ₹600) = ₹12,500. Catching it two days earlier saved ₹25,000 on a single account, in a single incident.

That's the whole argument in one calculation. The model made the change in a second and cost nothing. The value was created entirely by a human who looked, understood what "normal" looks like on this account, and had the standing to reverse it without a meeting. Run twelve accounts and one such incident a quarter, and the review function pays a salary by itself. If you want the sheet that surfaces this kind of drift, see your marketing either makes money or it doesn't and the definitions in marketing metrics explained.

What to stop investing in

Being honest about the other side of the ledger is more useful than another list of virtues.

Stop investing in	Why it is deflating	Invest instead in
Tool certifications as the main asset	Interfaces change; the certificate proves familiarity, not judgement	A public record of decisions and outcomes
Speed at routine production	Marginal cost of the first draft is heading to zero	Speed at reviewing and killing bad work
Memorised syntax and formulas	Recall is the cheapest thing a model does	Specification, trade-offs, system design
Being the person who "knows the process"	Processes get documented and then automated	Being the person who decides when the process is wrong
Volume of output as a personal brand	Everyone's volume just went up	Being right in public, on the record, repeatedly
Generic "learn to code because it's safe"	The safety premise is false	Coding as a way to think precisely, if you want it

None of these are worthless. They're just no longer scarce. Scarcity is what you're paid for.

How to build these in the next 90 days

A plan you could actually start on Monday, sized so it survives a busy week.

Weeks 1–2. Start the decision log. Write down every decision that cost more than an hour or ₹10,000, with your expected outcome and a review date. Ten entries is enough to begin.
Weeks 3–4. Pick one number in your work and formally ask to own it. Put a forecast in writing to whoever cares.
Weeks 5–8. Publish four pieces about how you actually do the work. Mechanisms, not opinions. This builds the writing skill and the trust asset at the same time.
Weeks 5–12, running in parallel. Contact two people a week from your fifteen-to-thirty list with something useful and no ask attached.
Weeks 9–12. Automate one recurring task of your own end to end. Then write down where the automation fails and what you had to check. That document is your verification skill, made explicit. How to automate your work with AI is the practical starting point.
Throughout. One deliberate unassisted rep per week. Keep the muscle.

FAQs

Should I still learn to code in 2026?

Yes, but for the right reason. Learn it because it teaches precise specification, debugging and systems thinking. Skills that transfer everywhere. Don't learn it as insurance against automation. Code is the most verifiable, most publicly documented text there is, which is exactly what models absorb fastest. Learn to direct and review code, not just to type it.

What jobs are safest from AI?

Roles where someone must carry liability, work physically in unstructured environments, or hold relationships that grant access. Regulated sign-offs. Skilled trades and diagnostics. Senior client ownership. Anything where being wrong has a named consequence. Safety comes from accountability and physical presence, not from technical difficulty. Difficult desk work automates faster than routine physical work.

Will AI make my skills useless?

It will make some tasks worthless and simultaneously raise the price of the skills around them. Drafting, summarising and routine production are deflating. Judging, deciding, verifying and being trusted are appreciating. The risk isn't owning no skills. It's owning only the deflating half and not noticing until your rate falls.

How do I build judgement when I am junior?

Volume of small reversible decisions plus a written record. Make calls, write down what you expected, review honestly. Ask to own one measurable outcome rather than a list of tasks. Sit in on decisions above your level and privately write down what you would have chosen. Then compare. Judgement is compressed feedback, so shorten the feedback loop.

Is prompt engineering a real skill worth learning?

The narrow trick version isn't. Models get better at interpreting sloppy input every release. The durable version is: writing a brief that is unambiguous, specifying what "good" looks like, and reviewing output critically. That's just clear thinking and clear communication applied to a new interface. It transfers to briefing humans too.

How do I stop AI from making me worse at my job?

Use it heavily where you can verify the answer, cautiously where you can only spot-check, never where you can't tell right from wrong. Keep one weekly unassisted rep in your core craft. And never let it make the final choice. Let it produce options and make the call yourself, so you can always explain why you shipped what you shipped.

Key takeaways

Automation follows verifiability, not difficulty, which is why "learn to code for safety" inverts the actual risk.
The durable test for any task is simple. If it goes wrong, does a named human get the phone call? If not, it's already commoditised.
Accountability, judgement under ambiguity, relationships, physical skill and taste are the five categories that resist automation. All five are deliberately buildable.
Directing AI is a genuine skill, but only in domains where you can verify the output. Outside those, you are accumulating unauditable claims, not knowledge.
Stop investing in certifications, memorised syntax and raw production speed. Start investing in a public record of decisions, outcome ownership and review capability.
A single caught error on a ₹25,000-a-day account saves ₹25,000 in two days. The review function pays for itself. That's the job.

DEV Community