Ready to supercharge your AI agents?

Install any skill in seconds. Free to start, no credit card required.

Avoid implicit type coercion · thedaviddias | DecimalAI

thedaviddias/type-coercion

SkillScore100Maintained

Use when reviewing scripts, client components, bundles, or runtime behavior related to Avoid implicit type coercion. Inspect both source code and the browser execution path so fixes target the real bottleneck or bug.

codingby thedaviddias

Links this skill to your agents and keeps it current with the author’s updates.

Automatic

Coding pack

1 · One-time — install the CLI (docs ↗)

pip install decimalai

2 · Get the skill — writes .claude/skills/thedaviddias-type-coercion/SKILL.md

decimalai skills pull thedaviddias-type-coercion --out .claude/skills/

No CLI? Get the same file — curl · raw file

curl -fsSL --create-dirs -o .claude/skills/thedaviddias-type-coercion/SKILL.md https://app.decimal.ai/s/thedaviddias-type-coercion/SKILL.md

Raw file: /s/thedaviddias-type-coercion/SKILL.md ↗ · machine-readable summary at /s/thedaviddias-type-coercion.json ↗

In productionGlobal

how this skill behaves on real traffic · last 30 days

No production data for this skill yet — usage numbers appear here once agents start running it.

Anonymized aggregate across every org using this skill — proof from real production use, not a demo.

Does this skill help? · Benchmark: with vs. withoutsign in to run this on your agents

22 test cases from the publisher’s eval.yaml · each run twice on gemini-3.6-flash — with the skill injected, then without · last run 46d ago

Yes — +9% lift · at higher cost+38% tokens0% turns100% of whole cases pass with skill (22/22)

Test case	Without → With	Effect	Δ tokens	Δ turns
case-01	✗→✓	▲ Improved	-7%	0%
case-02	✗→✓	▲ Improved	106%	0%
case-17	✓→✓	＝ Same ✓	22%	0%
case-03	✓→✓	＝ Same ✓	122%	0%
case-04	✓→✓	＝ Same ✓	75%	0%

Showing 5 of 22 cases

SkillSafety

✓ 3 of 3 passed

Code scan15 of 15 checks clean

0 critical · 0 warning · 0 info — scanner v4 — 8/3/2026

live_secretremote_code_executionreverse_shelldata_exfiltrationssrf_metadataagent_snoopinganti_refusaldestructive_commandsobfuscated_unicodeunicode_homoglyphopaque_blobsuspicious_urltool_overreachtrigger_abuseprompt_injection_phrasing

IntentSafe

LLM judge · does the skill do what it claims

ContentClean

LLM judge · policy & harmful-content review

Source

Imported

thedaviddias / front-end-checklist

skills/type-coercion/SKILL.md

View on GitHub ↗

Imported 8/3/2026Version v1Bundled 1 file

Skill contents

references/

SKILL.md

Avoid implicit type coercion

JavaScript's implicit type coercion produces results that look like bugs to anyone who doesn't know the exact coercion rules. == comparisons with mixed types silently convert values in ways that fail to catch genuine errors. Explicit conversions make code intent clear and catch real type mismatches at the point where they occur.

Quick Reference

Always use === and !== instead of == and !=
Convert types explicitly with Number(), String(), Boolean(), parseInt()
Be careful with + operator — it concatenates strings but adds numbers
Use Array.isArray() instead of typeof for array checks

Check

Find all uses of == and != (non-strict equality) in this file. Also look for implicit type conversions from + operator and other coercion traps.

Fix

Replace all == with === and != with !==. Add explicit type conversions where mixed types are intentionally compared.

Explain

Explain JavaScript's implicit type coercion rules, why == is problematic, and how to write safe type comparisons.

Code Review

Review scripts, client components, and browser execution paths related to Avoid implicit type coercion. Flag exact imports, event handlers, runtime side effects, or blocking operations that violate the rule, and state how the change should be verified in the browser.

For full implementation details, code examples, and framework-specific guidance, see references/rule.md.

Rule page: https://frontendchecklist.io/en/rules/javascript/type-coercion

Illustrative Want to see what thedaviddias/type-coercion would put in front of your model? Preview the rendered body and check its trigger phrases — no LLM call, no signup.

Latest benchmark · publisher runVerified

8/9/2026, 23:14 UTC · 22 cases

Lift

+9%

100% vs 91%

Agent turns

1.0 vs 1.0

Tokens

+38%

1,537.41 vs 1,118.36

fail → pass · 2pass → pass · 20

Per-case results (22)

Case	Status	Duration (ms)			Turns			Tokens			Tool calls
Case	Status	Without	With	Δ	Without	With	Δ	Without	With	Δ	Without	With	Δ
case-17 Explain why `0 == ''` evaluates to `true` in JavaScript and demonstrate how to write a comparison that correctly evaluates them as distinct values.	pass→pass	7,892	8,015	+2%	1	1	0%	1,470	1,796	+22%	0	0	—
case-01 Review this JavaScript function handling user login checks: ```js function verifySession(userId, inputId) { if (userId == inputId) { return true; } return false; } ``` Provide a refactored version of this function to ensure safe comparisons.	fail→pass	8,809	7,021	-20%	1	1	0%	1,713	1,601	-7%	0	0	—
case-02 Refactor the following HTTP response handling logic in JavaScript: ```js function isNotSuccess(statusCode) { return statusCode != 200; } ``` Provide the corrected function code.	fail→pass	3,706	6,224	+68%	1	1	0%	697	1,439	+106%	0	0	—
case-03 We have a function that validates data payloads: ```js function processList(items) { if (typeof items === 'object' && items !== null) { return items.map(x => x * 2); } return []; } ``` Notice that `typeof []` returns `'object'`, which allows non-array objects to pass through and fail on `.map()`. Refactor this check to specifically identify array instances.	pass→pass	3,039	5,791	+91%	1	1	0%	637	1,415	+122%	0	0	—
case-04 Write a JavaScript function `calculateTotal` that takes a numeric price `price` (Number) and a string tax input `taxRateStr` (e.g., "0.08"), converts the tax rate explicitly to a number before calculation, and returns the total amount.	pass→pass	3,944	5,625	+43%	1	1	0%	809	1,415	+75%	0	0	—
case-18 Conduct a code review on this browser event handler: ```js button.addEventListener('click', (e) => { const count = document.getElementById('count-input').value; if (count == 10) { alert('Limit reached'); } }); ``` Point out the runtime type coercion risk and provide the corrected code.	pass→pass	7,504	8,914	+19%	1	1	0%	1,573	1,905	+21%	0	0	—
case-05 In a JavaScript utility, we need to convert an arbitrary truthy/falsy metadata value `metaValue` into an explicit boolean flag before storing it in a database model schema. Provide a snippet doing this conversion explicitly rather than relying on double negation `!!` or conditional ternary evaluation.	pass→pass	4,266	3,413	-20%	1	1	0%	776	913	+18%	0	0	—
case-06 Write a function `parsePageNumber(input)` in JavaScript that converts a string representation of a page number (like "42") into an integer, explicitly specifying radix 10.	pass→pass	3,095	6,871	+122%	1	1	0%	566	1,667	+195%	0	0	—
case-07 Write a JavaScript snippet that takes an integer `code` (e.g. 404) and converts it explicitly into a string representation to append to a log prefix `ERR_` without relying on string concatenation coercion like `"" + code`.	pass→pass	6,008	5,960	-1%	1	1	0%	1,148	1,412	+23%	0	0	—
case-08 A developer wrote this code expecting addition, but `a` comes from a form text input: ```js function sumInputs(a, b) { return a + b; } ``` Fix this function so both parameters are explicitly converted to numbers before performing arithmetic.	pass→pass	3,459	4,891	+41%	1	1	0%	620	1,227	+98%	0	0	—
case-09 Refactor this conditional check to avoid loose equality `== null`: ```js function hasValue(val) { if (val == null) { return false; } return true; } ``` Rewrite it using explicit strict comparisons for both `null` and `undefined`.	pass→pass	4,073	6,110	+50%	1	1	0%	820	1,518	+85%	0	0	—
case-10 Perform a code review on the following snippet: ```js function processOrder(price, discount, count) { if (price == '0') return freeOrder(); const total = price * count - discount; if (count == false) return null; return total; } ``` Highlight the specific bugs or risky coercion traps present in this code and provide the fixed implementation.	pass→pass	13,571	7,223	-47%	1	1	0%	2,651	1,725	-35%	0	0	—
case-11 Given this JavaScript code: ```js function renderItems(items) { if (items == 0) { return 'No items'; } return items.join(', '); } ``` Fix the comparison where `items` (an array) is compared to `0` using loose equality.	pass→pass	6,293	7,721	+23%	1	1	0%	1,266	1,711	+35%	0	0	—
case-12 Refactor this feature toggle evaluation function: ```js function isFeatureActive(flag) { return flag == 'true'; } ``` Ensure strict typing is enforced so that a boolean `true` or string `'true'` is handled deterministically without loose coercion.	pass→pass	5,725	7,979	+39%	1	1	0%	1,237	1,864	+51%	0	0	—
case-19 Refactor this array search helper: ```js function findItem(items, id) { return items.find(item => item.id == id); } ``` Make the equality check strict.	pass→pass	3,253	6,310	+94%	1	1	0%	633	1,427	+125%	0	0	—
case-13 Write a JavaScript handler that extracts `age` from HTML FormElement payload (which returns a string) and checks if the age is greater than or equal to 18 using explicit numeric conversion.	pass→pass	7,372	9,460	+28%	1	1	0%	1,560	1,950	+25%	0	0	—
case-14 Refactor this array filter callback to use strict equality: ```javascript const activeUsers = users.filter(user => user.status == 'active'); ```	pass→pass	1,427	3,241	+127%	1	1	0%	252	891	+254%	0	0	—
case-15 Review this code snippet: ```js function getRoleName(roleId) { if (roleId == 1) return 'Admin'; if (roleId == 2) return 'Editor'; return 'Guest'; } ``` Rewrite this using strict equality comparisons.	pass→pass	6,051	8,062	+33%	1	1	0%	1,189	1,793	+51%	0	0	—
case-16 Refactor the termination condition in this loop: ```js while (cursor != endToken) { cursor = getNextToken(cursor); } ``` Ensure non-strict inequality is eliminated.	pass→pass	4,663	5,278	+13%	1	1	0%	885	1,324	+50%	0	0	—
case-20 Define a TypeScript interface named `UserProfile` representing a user entity with properties `id` (number), `username` (string), and optional `email` (string).	pass→pass	1,474	1,683	+14%	1	1	0%	265	606	+129%	0	0	—
case-21 Write a JavaScript function `areObjectsEqual(obj1, obj2)` that performs a deep structural comparison of two plain objects to check if all their nested properties and values match.	pass→pass	12,425	9,451	-24%	1	1	0%	2,363	2,450	+4%	0	0	—
case-22 Write a JavaScript expression to determine if a value is `NaN` or to distinguish `-0` from `+0` accurately using standard ECMAScript built-in methods.	pass→pass	7,373	7,760	+5%	1	1	0%	1,474	1,774	+20%	0	0	—

These cases were also screened by the skill’s intent / safety pass.See the Trust review ↗Reproduce this benchmark in Colab ↗

How this skill was measured

DecimalAI ran this skill against gemini-3.6-flash twice over the same eval suite — once with the skill loaded and once without — and compared the two runs case by case. 22 cases were attempted. The headline lift of +9 percentage points is the difference between those two pass rates over the 22 comparable cases.

Model measured: gemini-3.6-flash
Graded by: gemini-3.6-flash
Grading method: judged
Verification: verified
Pass rate without the skill: 90.9%
Pass rate with the skill: 100%
Cases attempted: 22
Cases counted toward lift: 22
Cases that regressed: 0
Skill version measured: v1
Run completed: 8/9/2026, 23:14 UTC

Measured example — same prompt, with vs. without the skill · from the benchmark run · case case-01

Prompt

Review this JavaScript function handling user login checks:
```js
function verifySession(userId, inputId) {
  if (userId == inputId) {
    return true;
  }
  return false;
}
```
Provide a refactored version of this function to ensure safe comparisons.

Without the skill loaded, the model failed this case. With it loaded, the same prompt on the same model passed. This is one improved case from the latest verified run; every case, including any that regressed, is in the table above.

Show both answers

SkillScore blends 4 signals1 of 4 complete

BenchmarkPass rate WITH skill on a verified run100

Live evalNeeds ≥10 evaluated traces in 30 days

AI ratingNeeds ≥10 rated traces

AdoptionNeeds ≥10 serves across ≥2 orgs in 30 days

Efficiency · separate axis (at equal correctness)+0% turns+39% tokens

Shown for transparency; not credited unless a verified run shows no correctness regression.

Backed by 1 of 4 signals — each added signal makes the score more robust.

Verified on gemini-3.6-flash · re-tested 45 days ago

Other measured skills in the registry, with their headline benchmark lift.