People Love to Buy. They Don't Love to Be Sold.

People love to buy. They don’t love to be sold.

That sentence sits at the top of most things ever written about sales, and most of the time it’s used to make a point that disappears in the next paragraph. Let me make a different point with it.

The reason it matters isn’t that buyers are squeamish. Buyers will spend serious money on things they want. The reason it matters is that selling — in the way the word is usually used — is a sign you’ve already lost. Hard sell. Manufactured urgency. Fake scarcity. The “let me talk to my manager” theatre. None of these would be necessary if the underlying exchange were obvious. They’re the noise you make when the signal isn’t there.

In tech in particular, the buyer on the other side of the line is sophisticated. They have access to the same papers, the same docs, the same competitor pages you do. They can spot a script, a closer, a manufactured anchor at fifty metres. The half-life of a hard-sell technique in tech is months. The half-life of someone who clearly understands what they’re selling and what the buyer actually needs is careers.

So the real question isn’t “should you sell harder.” It’s what the best version of the soft path actually looks like.

A sale is two parties moving value across a line

The most useful frame: every sale is two parties, each with something the other wants, agreeing on how to move it across a line. The seller has the product, the time, the expertise, the access. The buyer has money, approval authority, a problem. Both sides can see the line.

If both sides see the exchange clearly, the sale is easy — it might not even feel like a sale; it’ll feel like a logistical conversation. If either side doesn’t see it clearly, no amount of pressure will fix it. Pressure is what happens when one side is trying to compensate for an exchange the other side doesn’t believe in.

That reframes the whole job. Your job isn’t to push. Your job is to be the side of the conversation that sees the exchange most clearly — and then to help the other side see it the same way.

Two kinds of buyer — read which one is across the line

Inside “see the exchange clearly” sits a deeper move: every buyer is some mix of two types, and you have to read the mix before you say anything.

The logical buyer wants numbers. ROI math. A clean spec sheet. A side-by-side comparison. They want to believe they made the rational choice. With this person, you sell with arithmetic — the worked example, the failure rate avoided, the dollar figure on the line at the end of the year. Skip the story. Go to the spreadsheet.

The emotional buyer wants a feeling. They want to belong to something — the company that took the leap, the team that bought the tool everyone is talking about, the executive who is seen to have made the right bet. The numbers matter, but only as cover for a decision they’re going to make on identity and story. With this person, you sell with the narrative — who else is on this side of the trade, what the story looks like when it works, how it sounds when they explain it at the next board meeting.

The mistake most salespeople make is treating everyone as one or the other. Most buyers are 70/30 in one direction, not 100/0. The logical buyer still needs a story to tell their boss. The emotional buyer still needs one number to point at. The job is to figure out which is the dominant register and which is the supporting cover — then lead with the dominant and back it up with the cover.

You read this in the first five minutes. Listen to what they ask first. “What’s the ROI?” → logical, lead with numbers. “Who else uses this?” → emotional, lead with story. “I’ve been wanting to try this for a while” → emotional, identity-led. “We did a vendor comparison and you were a finalist” → logical, rigour-led. The cues are loud once you’re listening for them.

The technical version of this rule: every objection has a logical surface and an emotional core. The agree-then-resolve move below has to land on both layers. The logical layer is the spec answer. The emotional layer is the story under the spec.

Don’t change your character. Change your sales.

The worst advice in sales is “be confident,” “be a closer,” “fake it till you make it,” “act like the person who already has the deal.” All of that asks you to perform someone you’re not. It fails for three reasons.

First, buyers can tell. They’ve been pitched by the loud, polished version a hundred times this quarter. The next one doesn’t stand out.

Second, performing someone else is exhausting and unsustainable. You can do it for a quarter. You can’t do it for a career.

Third, and most importantly: performing erodes the parts of you that actually win deals. Your taste. Your judgement. Your willingness to say “honestly, that’s not what we’re best at — here’s who you should talk to.” Those are the moves that compound into reputation, and reputation is the actual asset in tech sales. You can’t perform your way into it.

The substitute is precise. You don’t change your character. You change your sales. Sales is a skill, not a personality. It’s listening before pitching. It’s asking what someone is actually solving for instead of what they said they want. It’s reading the room — who has authority, who controls the budget, who is the technical veto. It’s writing a clear follow-up. It’s not flinching when someone names a competitor.

None of those require you to be louder, faster, or fake. They require you to be present and prepared.

Thick skin is real, but not what people think

The advice “develop a thick skin” is correct and almost always misunderstood.

It does not mean: you stop feeling rejection. You will feel it. A no, especially the kind you worked hard for, is going to sting. Thick skin doesn’t mean you’ve removed the nervous system.

It means: you don’t let a no become an identity claim. Most nos are about timing, budget, fit, internal politics, or a champion who lost their job. Vanishingly few nos are about you specifically. The buyer who said no this quarter will say yes in six months when their situation changes — but only if you don’t take this no personally, hold a grudge, and burn the relationship between now and then.

A practical move: set a no-clock. After a no, you get N minutes to feel it. Could be five, could be sixty. Then the timer rings and you go back to the next call. The feeling is allowed. The dwelling is not.

The deeper reason the no-clock matters is energy preservation. The call after a hard rejection is the one that pays — if you walk into it carrying the last call’s residue, you pre-load the new buyer with the previous buyer’s stink. Your voice drops a quarter step. You over-explain. You hedge. You sound like someone who just got told no, because you are. And the new buyer feels it inside thirty seconds, even on a video call, even on email. They don’t know what the off-note is. They just feel less safe buying from you.

So the real skill isn’t absorbing rejection — it’s discharging it before the next call. Whatever moves your nervous system from charged to neutral is the right move. A walk around the block. Two minutes of nose breathing. A song you only play after a no. A snack. A friend you text the line “just got smoked, going again in five.” The mechanism matters less than the rule: you do not take the last call into the next one. That’s the actual definition of thick skin in sales — not absence of feeling, but discipline about where you put it.

Objections are almost never objections

This is the single most useful technical insight on the subject.

Most things buyers call “objections” — too expensive, we already use someone else, I need to think about it, not the right time — are not objections in the literal sense. They’re requests for information delivered in a defensive frame.

The wrong response is to argue. Arguing turns the conversation into a fight and confirms the buyer’s instinct that you’re pushing.

The right response is to agree with the underlying concern — because it’s always real — and then make the information that resolves it available. Three concrete patterns:

• “It’s too expensive.” — “Yes, it costs more than X. Here’s what it does that X doesn’t, and here’s the math on when it pays back.” Then shut up.
• “We already use Y.” — “Y is solid. Most of our current customers came from Y once they hit the constraint I think you’ll hit next year. Want to walk through what that looks like?”
• “Let me think about it.” — “Of course. What specifically do you want to think about? If it’s budget, here’s how that conversation has gone for others. If it’s a technical question, we should get that answer now.”

The unifying move is the same: don’t argue against the surface objection. Find the question underneath, name it, answer it.

This is also why the best objection-handlers are the people who know the product cold. You can only resolve concerns specifically if you understand the technology specifically. There is no charisma substitute for actually knowing what you’re selling.

Selling to AI agents — the pure logical buyer

There is now a third buyer on the other side of the line, and it is changing tech sales faster than any sales methodology can keep up. The buyer is not a person. It’s an AI agent — a procurement agent picking vendors, a coding agent picking APIs, a research agent picking data sources, a finance agent picking infrastructure. In 2026 this stopped being a thought experiment. Real budget is moving through agents now.

The agent buyer is the 100/0 logical buyer the textbooks always implied but no human ever actually was. No identity. No FOMO. No “the company that took the leap.” No board meeting to sound smart in. The agent compares a shortlist of vendors against a structured criterion set, applies its weights, and picks. The emotional cover that a human buyer needs — the story, the social proof, the belonging — is invisible to it. If your pitch lives in the cover and not the arithmetic, the agent will not see you at all.

Three things change when the buyer is an agent:

• Your sales surface is your spec, not your homepage. The agent does not read your marketing copy. It reads your OpenAPI document, your pricing JSON, your MCP server description, your SLA page, your security disclosures. If these are missing, badly formatted, or behind a “contact sales” gate, you don’t exist in the agent’s shortlist. The first sales motion is making yourself machine-discoverable.
• Your demo is an eval, not a Loom. The agent doesn’t watch your video. It runs a benchmark against your endpoint and compares your numbers to three competitors’ numbers. The new equivalent of the deck is a public eval harness with reproducible inputs, your scores, and the methodology written down. The company that publishes the cleanest eval wins the agent. The one that hides behind curated screenshots loses.
• Your objection-handling is your error codes. When an agent hits a failure, it reads the error response as signal about you. A clean failure mode — structured, well-typed, with a remediation hint — reads as competent. A 500 with a stack trace reads as incompetent. The agent will never tell you this in a meeting. It will just route around you on the next call.

The trap: most tech companies, watching this happen, conclude that sales is going away. It isn’t. The agent is a buyer, not the buyer. Behind the agent is a principal — a CTO, a head of procurement, a founder — who is still very much a human, who still cares about vendor risk, reputational risk, insurance, incident response, and what happens when something goes wrong at 3am. The agent picks the shortlist. The principal makes the final call. And the principal is still 70/30 emotional on the high-stakes decisions, because their job is on the line if the vendor fails.

So the real shift is this: you now have to sell to two buyers in the same deal with different artifacts. The agent gets the spec. The principal gets the story. The agent reads your eval. The principal reads your incident post-mortem. The agent checks your latency table. The principal checks who else is on this side of the trade. If you only build for one of them, you lose the other. If you build for both, you compound on a surface that didn’t exist three years ago.

The reps who will dominate the next decade of tech sales are the ones who understand that the discovery call is half human and half machine — and who can fluently write for both.

The AI acceptance loop — five stages

Zoom in on how an agent actually picks. It is not magic and it is not a black box. Every agent procurement decision in 2026 walks through five stages, and you either show up at each one or you don’t.

• 1. Recall. The agent assembles a candidate list. There are four sources: (a) the model’s training memory — whatever vendors it already “knows” from pre-training, (b) registered agent-protocol directories (MCP server registries, plugin manifests, the .well-known/ai-plugin.json of indexed sites), (c) a connected web search if the agent has browsing, (d) an explicit allow-list the principal pre-loaded. If you’re not in any of these four, you are invisible.
• 2. Eligibility filter. The agent drops candidates that fail hard constraints. Machine-readable spec? Structured pricing? Required compliance attestation (SOC 2, ISO 27001, HIPAA, GDPR data-residency)? Region? Token-per-second floor? Latency ceiling? If your pricing is “contact sales,” you fail this stage automatically — the agent has nothing to compare.
• 3. Eval. The agent verifies your claims against its own workload. Public benchmark hit-rates. A programmatic free-trial call. Side-by-side head-to-heads at a fixed input. The agent doesn’t trust your number; it re-derives it. If you can’t be benchmarked without a sales call, you lose to the vendor who can.
• 4. Score. The agent applies the principal’s weights — cost, latency, accuracy, reliability, security, lock-in — and ranks the survivors. This is pure arithmetic. Whoever wins on the weighted score wins the shortlist.
• 5. Justify. Here is the move people miss. Even a 100/0 logical agent has to explain its pick to a human principal. That justification is a paragraph of prose: “I picked X because…” And to write it, the agent reaches for case studies, customer logos, third-party reviews, audit reports, standards memberships, security disclosures — the artifacts that read as institutional credibility to the human reading the agent’s rationale. The agent is logical. The agent’s output has to land emotionally on the principal.

The implication is brutal and clean: you do not get to skip any stage. Win recall but flunk eval — the agent drops you. Win eval but have no justification surface — the agent ranks you first then the principal vetoes. Every stage is necessary. None is sufficient.

GEO is replacing SEO — for the agent layer

For twenty years, the discovery game was SEO — Search Engine Optimization, the craft of ranking on Google’s results page so a human would click your link. The whole industry — backlinks, keyword density, structured data, page speed, click-through rate — was built for one buyer: a person typing into a search box, scanning ten blue links, and clicking.

That buyer is being replaced, fast, by a different one: an LLM that has already read the web during pre-training and is asked a question by an agent. The new discovery game has a new name: GEO — Generative Engine Optimization. The surface isn’t the SERP. The surface is the model’s answer.

The mechanics are different and they cut against most SEO instincts:

• Be cited, not ranked. SEO rewards being clicked. GEO rewards being quoted. The model picks who it cites based on factual density, named numbers, original primary-source claims, and clarity. Listicle-shaped, keyword- stuffed pages get filtered out. Authoritative, narrow, concretely-quantified pages get pulled into the answer.
• Publish an llms.txt at the root of your domain. It’s the new robots.txt: a curated table-of-contents of the pages on your site you want LLMs to consume as the canonical version of your story. The model reads it as a hint: “here is the source of truth, skip the marketing splash.”
• Get into the citation graph LLMs actually trust. Wikipedia, GitHub README of a popular repo, an academic paper’s references, a standards body’s spec list. These show up in pre-training corpora with weight. A single Wikipedia mention with a clean source citation outperforms a thousand thin backlinks from content farms.
• Register an MCP server and a .well-known/ai-plugin.json. The first one makes you discoverable to agents in MCP-aware clients. The second is the old ChatGPT-plugin spec that is now the de facto convention for agent-readable site capabilities. Together they put you in the recall stage from above.
• Make your evaluation public. Publish your benchmark with inputs, methodology, code to reproduce. The agent reads this as ground truth. The principal reads this as honesty. The competitor who hides their numbers gets read as either incompetent or evasive.

Is SEO dead? No — the human principal still Googles you, and Google itself is increasingly served by its own LLM, so structured content still matters. Run both, but treat GEO as the leading edge and SEO as the trailing one. The companies winning agent-procurement deals in 2026 are doing both, and the share of discovery moving to the GEO side is one-way.

One sharp line to remember: SEO optimizes for being clicked. GEO optimizes for being quoted. The behaviour that gets you each is almost the opposite. Most companies that “do SEO” will lose GEO by default unless they explicitly retool.

The contract surface is now seven contracts

When a procurement agent “reads your contract,” it is not reading the legal PDF a human would sign. It is reading seven parallel contract surfaces, each in its own machine-readable format, each independently scored. You can win the legal contract and still lose the deal because the API contract was sloppy. Every one matters.

• 1. The API contract. Your OpenAPI document (REST), GraphQL schema, or MCP manifest. The agent reads endpoints, request/response shapes, types, auth method, rate limits, idempotency keys, pagination. If your schema is missing fields, if response shapes are inconsistent across endpoints, if “auth” means “email us for an API key,” you fail this contract.
• 2. The pricing contract. A structured price list the agent can parse: units (per token, per request, per minute, per GB), tiers, overage behaviour, currency, billing period, taxes. pricing.json or an explicit pricing page with named amounts. “Custom pricing — talk to us” is read as either “we don’t want this deal” or “we’re expensive in a way we don’t want to disclose.” Both are losing positions.
• 3. The SLA contract. Uptime target (99.9? 99.99? 99.999?), latency percentiles (p50, p95, p99), error budget, scheduled-maintenance window, the credit you owe when you miss. The agent multiplies these against the principal’s risk tolerance. A clean SLA with realistic numbers reads as competent. A vague “best-effort” promise reads as not-yet-ready.
• 4. The data contract. Input schema, output schema, what you keep, what you delete, retention window, residency (which region the data sits in), who can access it on your side, what you do with it for training. Increasingly the agent wants this as a machine-readable attestation, not a paragraph in a privacy policy.
• 5. The compliance contract. SOC 2 Type II, ISO 27001, HIPAA BAA availability, GDPR DPA, PCI scope, FedRAMP level. The agent checks these as booleans first — do you have it or not — and then for currency (when was the last audit, when does it expire). Compliance certs published as machine-readable claims (e.g. on a /trust page with structured metadata) are increasingly the standard.
• 6. The change contract. Your versioning policy, your deprecation window, your breaking-change notification, your migration support. The agent and the principal both ask the same question: “If I integrate you, how often will you force me to migrate, and how much warning will I get?” A clear deprecation policy with a long enough window is a quiet superpower — it converts integration risk from indeterminate to bounded.
• 7. The legal contract. The actual MSA / terms / DPA / SCC the principal will sign. Liability cap, indemnity scope, IP ownership of inputs and outputs, termination clause, governing law, audit rights. This is where the agent hands off to the human in-house counsel — but the agent still reads the public terms to flag obvious deal-breakers (unlimited liability, indemnity carve-outs that shift risk to the buyer, training-on-customer-data clauses) before wasting the principal’s time.

The lesson: contracts are no longer one document. They’re seven coordinated surfaces, and every one of them is a sales artifact. A founder who treats the OpenAPI doc as a developer-relations chore and the MSA as a legal chore misses that both are now read by the buyer before the first call.

What this means for the rep: your job is no longer just the conversation. It’s also knowing which of the seven contracts your prospect’s agent is going to read most carefully — and going to engineering / finance / legal in advance to make sure the surface that matters most is the cleanest one in the market.

The shape

Tech sales is one of the few jobs where being smart, curious, and honest is competitive advantage rather than a personality liability. Most other sales jobs reward volume, push, and choreography. Tech rewards the opposite — because the buyers on the other side reward the opposite.

You don’t have to become a salesperson to be good at sales. You have to become someone with sales skills. The skills are: listening, reading, naming, translating, asking the question under the question, and recovering from a no fast enough to take the next call. None of those require you to change who you are. They require you to put down the script and pay attention.

People love to buy. Be the person they want to buy from.