A step by step guide to world class account scoring in under two hours

Part 1 argued that a good account score is the start of a prospecting conversation, not a verdict. Every number should be backed by people and teams a rep can see and act on.

Here is how to build one against your own ICP using the Sumble account scoring skill, which runs in Claude Code, Codex, or Cursor. One skill, three objectives: score the accounts in your CRM, find whitespace (strong-fit orgs you don't yet have), or both in one ranked sheet. You talk to it, it pulls the data, it calibrates to your closed-won, and you tune with sliders. If python app.py runs, you are done.

What you need

• One coding agent: Claude Code, OpenAI Codex, or Cursor.
• The Sumble account scoring skill — installed in step 1 below, with one npx skills command or by copying a folder.
• A Sumble account, API key, and the Sumble MCP connected.
• Your CRM accounts if you want to score your own book — name and domain — provided as a CSV or pulled from a connected MCP/API source. The skill can use your whole CRM, which accounts are allocated to a rep, and your closed-won customers — as one table with flag columns or as separate lists. None are required, but closed-won is the one worth digging up: it powers the evaluation that checks your known-good accounts rise to the top.

1. Install the skill

A skill is just a folder of instructions your coding agent reads — there are two ways to get it.

Have npx? (it ships with Node.js) — one command installs the skill into whichever agents you choose:

npx skills add SumbleData/sumble-skills --skill sumble-account-scoring

The installer detects your coding agents and asks where to install. For a no-prompt global install into one agent, add -g -a claude-code -y, -g -a codex -y, or the matching agent name.

No npx? No git? No problem — install it by hand:

1. Download the skills repo as a ZIP (no git needed): github.com/SumbleData/sumble-skills → Code → Download ZIP, then unzip it.
2. Copy the skills/sumble-account-scoring folder into your agent's skills directory (~ is your home folder; create the directory if it doesn't exist):
   • Claude Code: ~/.claude/skills/sumble-account-scoring
   • OpenAI Codex: ~/.codex/skills/sumble-account-scoring
   • Cursor: ~/.cursor/skills/sumble-account-scoring

Either way, start a new agent session so the skill is picked up, then run it: in Claude Code type /sumble-account-scoring; in Codex or Cursor, ask the agent to use the sumble-account-scoring skill.

2. The interview

The first step is short and scripted. The skill pulls a first draft of your ICP from your Sumble profile: personas, technologies, projects, and related buying attributes. You edit it in plain English until it matches how your team sells.

It also proposes the score's segments — the top-level lenses it breaks the number into. The default is three: Size (how big the opportunity is), Growth & momentum (whether now is the time), and Concentration (how strong the fit is), with a starting blend of ~50/30/20 — a default starting point, not the final weighting that the skill later fits to your closed-won deals (step 4). Keep them, reweight them, or redefine them — the skill suggests a business-unit breakdown if you sell distinct product lines. Funding deliberately isn't part of the default model — funding data only exists for venture-backed companies, so scoring it artificially boosts them (see part 1). If webinar attendance, whitepaper downloads, events, free-tier users, or product usage matter, point the skill at first-party data keyed by account and those become weighted factors too.

3. Which accounts to score

Every account lands in one category — customer (closed-won), allocated (in CRM, owned by a rep), unallocated (in CRM, no owner), or whitespace (a strong-fit org not in your CRM). The app shows that category as a column and lets you filter on it, so one ranked list serves territory planning, allocation gaps, and net-new at once.

• Score your accounts. Point the skill at your account list and choose: score them all, or have it draw a representative stratified sample (≈30% closed-won, 40% rep-allocated, 30% unallocated). For a large CRM — where most accounts are stale and scoring everything just burns credits — a sample (or a subset you specify, like just rep-allocated) calibrates on the accounts that matter. It shows the credit estimate before any large pull.
• Fold in whitespace. Say yes and the same skill, run in whitespace mode, ranks strong-fit orgs that aren't in your CRM — resolving your whole CRM universe to exclude what you already have — and drops them into the same sheet tagged whitespace. The ranking itself is free (only the final enriched pool costs credits), drawn from a diversified preselection so the pool isn't just the biggest companies. Candidates whose parent is already a CRM account are flagged as land-and-expand. Whitespace runs the Sumble-only half of your model, and the same gold-set calibration carries straight over.

The skill shows a credit estimate before any large pull, then builds the app.

4. Tune and click through

cd account_scoring/<your-company>
python app.py        # http://localhost:8001

Drag the sliders and the ranking re-sorts instantly. Open any account for a per-attribute breakdown. This is where the score becomes actionable: each attribute deep-links into Sumble, filtered to the entities behind it.

DevOps engineer headcount opens the actual engineers. Teams using Jenkins opens those teams. Migration intent opens the recent job posts. A rep goes from score to named contacts and talking points in two clicks.

If you loaded CRM lists, the category chips above the table filter to customers, allocated, unallocated, or whitespace in one click — so you can pull up "high-scoring accounts with no rep" or "top whitespace" without exporting anything. The slider weights apply across every category at once.

Use the sliders to correct for the bias you want to avoid. By default scores tilt toward big companies; the sliders are split so you can correct that on purpose. Selling into small, fast-growing companies? Turn growth up, especially ICP-persona growth. Want accounts where your product is central rather than incidental? Turn concentration up. Then use the Evaluation tab to see whether your won deals actually rise.

The skill also fits to your wins carefully. It learns tag multipliers from over-represented and under-represented Sumble org tags among your gold set (for example a digital-native boost, or a professional-services penalty) — calibration runs over org tags, not a per-industry multiplier; industries you obviously don't sell to are excluded or penalized in the interview instead. It makes an intelligent first guess at the weights, then a small solver takes a deliberately light pass — nudging only the high-level segment and category weights toward your closed-won accounts. It stays coarse to avoid overfitting: it never tunes at the most granular level (individual job functions, technologies, and projects keep their default within-segment weighting), shrinks changes back toward the defaults, cross-validates on held-out wins, and is adopted only when it generalizes — on a thin gold set it does not move at all. The fitted weights are a starting point you can override. The Evaluation tab shows the payoff: it reports how many gold accounts land near the top (a lift above 1.0 beats random) and breaks down where each category lands in the overall ranking, so you can confirm your customers cluster near the top. Drag, watch the gold rise, then Save — it writes your tuned weights and one complete score.csv.

5. Score your whole book and keep it fresh

Two artifacts come out of tuning:

• account-scoring-weights.json. Your model as plain JSON: weights, normalization parameters, and each attribute's mapping back to Sumble data.
• score_accounts.py. A zero-dependency runner that reads the JSON and scores any list of accounts.

For a one-off score across your whole book, run the portable scorer against Sumble's public API:

python score_accounts.py --accounts my_full_list.csv --out scored.csv

For daily scoring, do not keep paying per API call. The lighter path is to have Sumble feed the underlying attributes into your warehouse or CRM on a daily refresh, then recompute the score on a schedule and write the rank back where reps see it.

Teams with a data stack can re-implement the formula in SQL and run it through dbt, Airflow, Dagster, or Prefect. Teams with a little cloud infrastructure can use Cloud Scheduler and Cloud Run, or EventBridge and Lambda. GTM-owned teams can run the same workflow through Clay, n8n, Make, or Zapier.

What you hand reps is the rank, not the raw score. "Your #3 account" beats "an 82" every time. Rank within segments or territories so every rep has a clear top of their own book.

The payoff

Say you sell a platform-engineering tool to DevOps and infrastructure teams. Within an afternoon, you can see whether customers skew digital-native and recently funded, whether Kubernetes footprint predicts fit better than headcount, and whether a recent raise plus an active cloud-migration initiative is your strongest "buy now" combination.

Because every attribute links straight into the people, teams, and jobs behind it, the ranked list is not a leaderboard. It is a prospecting queue with the next action already attached. And the same skill, run in whitespace mode, turns it on the accounts you're not selling to yet — same model, minus the first-party attributes a stranger can't have.

n_i(a) = clamp((1 - exp(-x_i(a) / p_i)) / (1 - exp(-1)), 0, 1)

score(a) = 100 * sum_i(w_i * n_i(a)) * calibration_multipliers(a)

npx skills add SumbleData/sumble-skills --skill sumble-account-scoring

cd account_scoring/<your-company>
python app.py