AI Skill Report Card

Building Interactive Calculators

A-83·Nov 8, 2026·Source: Web
15 / 15
HTML
<div class="calculator" id="price-calc"> <label>Quantity: <input type="number" id="qty" value="1" min="1"></label> <label>Material: <select id="material"> <option value="10">Standard ($10/unit)</option> <option value="15">Premium ($15/unit)</option> </select> </label> <div class="result">Total: $<span id="total">10.00</span></div> </div> <script> function calculate() { const qty = Math.max(1, Number(document.getElementById('qty').value) || 1); const unitPrice = Number(document.getElementById('material').value); const total = qty * unitPrice; document.getElementById('total').textContent = total.toFixed(2); } document.getElementById('price-calc').addEventListener('input', calculate); calculate(); </script>

This pattern — inputs → formula function → live output binding — is the core of every calculator. Everything else (validation, multi-step logic, styling) builds on it.

Recommendation▾
Examples 2 and 3 describe approach in prose rather than showing concrete code/output like Example 1 — add actual code snippets for consistency
14 / 15

Progress:

  • Step 1: Define the formula and all variables (inputs, constants, output)
  • Step 2: Identify input types (number, select, radio, slider, toggle) and valid ranges
  • Step 3: Build the HTML structure with semantic labels
  • Step 4: Write a pure calculation function (inputs in → result out, no side effects)
  • Step 5: Wire up event listeners (input for live updates, change for selects)
  • Step 6: Add validation and edge-case handling (zero, negative, empty, max limits)
  • Step 7: Format output (currency, rounding, units)
  • Step 8: Add visual feedback (highlight result, animate changes, breakdown table)
  • Step 9: Test across edge cases and devices; verify formula accuracy against manual math
  • Step 10: Make responsive and accessible (labels, ARIA, keyboard input)

Step 1 details: Clarify the formula first

Before writing code, get the exact business formula from the client/stakeholder:

  • What are the base price, multipliers, discounts, taxes?
  • Are there tiered prices (e.g., bulk discounts)?
  • Any conditional logic (e.g., "if quantity > 100, apply 10% discount")?

Write the formula in plain math/pseudocode before touching HTML/JS.

Step 4 details: Pure function pattern

Always separate calculation logic from DOM manipulation:

JavaScript
function calculatePrice({ qty, unitPrice, discountThreshold = 100, discountRate = 0.1 }) { let subtotal = qty * unitPrice; if (qty >= discountThreshold) { subtotal *= (1 - discountRate); } return Math.round(subtotal * 100) / 100; }

This makes the formula testable independently of the UI and reusable if logic moves server-side.

Recommendation▾
Include a concrete input/output pair with real numbers (e.g., 'pages=600, binding=true → Total: $52.80') to make the formula verification tangible
15 / 20

Example 1: Tiered pricing calculator

Input: Client wants a calculator for printing services — base $0.10/page, bulk discount 20% over 500 pages, plus binding option (+$5 flat).

Output:

JavaScript
function calculate({ pages, binding }) { const base = 0.10; let subtotal = pages * base; if (pages > 500) subtotal *= 0.8; if (binding) subtotal += 5; return subtotal.toFixed(2); }

UI: number input for pages, checkbox for binding, live-updating total with a breakdown line ("Subtotal: $X, Discount: -$Y, Binding: +$5").

Example 2: Multi-step configurator

Input: Furniture site needs a calculator where users pick material, size (W×H×D), and finish, each affecting price multiplicatively.

Output: Use a config object mapping each option to a multiplier/surcharge, compute volume-based base price, then apply multipliers sequentially. Show running total updating after each selection, with a final "Request Quote" button that submits the configuration.

Example 3: Loan/mortgage calculator

Input: Real estate site needs monthly payment calculator from loan amount, interest rate, term.

Output: Standard amortization formula M = P * [r(1+r)^n] / [(1+r)^n - 1], implemented as a pure function, with sliders for amount/term and live-updating monthly payment plus a toggleable amortization table.

Recommendation▾
Consider adding a brief accessibility/ARIA code example since it's emphasized twice in Best Practices and Pitfalls but never demonstrated
  • Separate logic from presentation. Calculation functions should take plain data and return numbers — no DOM references inside them.
  • Update live, not on submit. Use input events for sliders/number fields so users see immediate feedback; avoid requiring a "Calculate" button unless the computation is expensive.
  • Validate aggressively. Clamp negative numbers, empty fields, and out-of-range values before calculating; never let NaN reach the display.
  • Format for humans. Use toLocaleString() or explicit formatting for currency/thousands separators; always show units.
  • Debounce expensive calculations (e.g., if hitting an API) with ~200-300ms delay; simple math needs no debounce.
  • Show the breakdown. Users trust calculators more when they see how the total was derived (subtotal, discount, tax, fees as separate lines).
  • Make mobile-first. Number inputs and sliders must be easily tappable; avoid tiny click targets.
  • Keep formulas in one place. If the same calculation logic exists in multiple pages, extract it into a shared module/function to avoid drift.
  • Persist state in the URL or localStorage for shareable/returnable calculators (e.g., quote links).
  • Don't hardcode magic numbers in the DOM manipulation code. Keep pricing constants in a config object at the top of the script for easy updates.
  • Don't trust client-side calculation for final transactions. Always re-validate/recalculate totals server-side before charging or confirming an order.
  • Don't forget floating-point rounding errors. Use Math.round(x * 100) / 100 or a decimal library for currency math instead of raw float arithmetic.
  • Don't let invalid input silently break the UI. Show inline error messages rather than displaying NaN or a blank result.
  • Don't overload a single input with multiple responsibilities. Each field should map clearly to one variable in the formula.
  • Don't skip accessibility. Missing <label> associations make calculators unusable with screen readers — always pair inputs with labels via for/id.
  • Don't ignore performance on complex configurators. If recalculating is expensive (large tables, API calls), throttle/debounce instead of recalculating on every keystroke.
0
Grade A-AI Skill Framework
Scorecard
Criteria Breakdown
Quick Start
15/15
Workflow
14/15
Examples
15/20
Completeness
17/20
Format
15/15
Conciseness
13/15