joSUu ostel
HomeBlogTurbo CalculatorkfaEcon Spectrum
← Back to Blog

A Framework for Thinking About AI's Role in Modern Computing

Abstract

We present a practical, evidence-first framework for deciding when to use traditional deterministic software (reliable, predictable code) and when to deploy modern AI systems like ChatGPT or other large language models (powerful but unpredictable). Rather than a collection of opinions, this document converts claims into testable hypotheses, ties those hypotheses to modern research and real-world case studies (2020–2025), and prescribes experiments to evaluate tradeoffs in accuracy, cost, speed, and failure severity. The result is a decision framework grounded in measurable outcomes and operational controls.

1. Introduction — from opinion to evidence

AI capabilities have advanced rapidly in the last five years, with systems like GPT-4[4] and Claude 3[16] reaching human-level performance on many standardized benchmarks. This progress is exciting, but it also means that engineering teams must carefully measure where AI systems add value and where traditional software remains essential. The goal of this paper is pragmatic: when we assert "AI is better for X," we will attach (1) a testable hypothesis, (2) an experiment or measurement plan, and (3) the research or case studies that motivate it.

Why this matters: Modern AI systems introduce new operational costs and failure patterns that differ from traditional software. Despite 78% of organizations using AI in at least one business function as of 2024[22], research shows that 70-85% of generative AI deployment efforts fail to meet their desired return on investment[24], with only 26% of companies generating tangible value from AI at scale[21]. A data-driven approach replaces hype with reproducible evidence.

(Key reading: Sculley et al., "Hidden Technical Debt in ML Systems"[1]; OpenAI/Anthropic/Google production reports[2]; recent LLM capability & evaluation papers.)

2. Two Engines of Computing

2.1 The Deterministic Engine (Traditional Code)

Think of traditional software like a calculator or database query—it produces the same output every time you give it the same input.

Characteristics:

  • Predictable: Always produces consistent outputs for the same inputs (like a calculator: 2+2 always equals 4).

  • Debuggable: Easy to test and troubleshoot; errors are systematic and can be traced to specific causes.

  • Mission-critical friendly: Best when even occasional incorrectness could be catastrophic (financial calculations, compliance systems, medical devices).

Supporting evidence: Software engineering research emphasizes that deterministic components are essential for systems requiring guaranteed correctness and for creating safety boundaries around less predictable AI components.

Hypothesis to test: On tasks requiring bit-exact transformations or strict validation, deterministic implementations will achieve near-perfect correctness and far lower catastrophic failure rates than LLM-based solutions.

Suggested metrics: absolute error rate, catastrophic failure rate, reproducibility (variance across runs), and test coverage.

2.2 The Probabilistic Engine (AI Models)

Think of AI models like a knowledgeable but imperfect human consultant—they excel at interpreting messy, ambiguous requests and generating creative solutions, but they sometimes make confident-sounding mistakes.

Characteristics:

  • Flexible interpreter: Excels at understanding ambiguous, unstructured inputs and generating human-like outputs (text, code suggestions, summaries).

  • Graded responses: Produces nuanced answers with uncertainty, but occasionally "hallucinates" (makes confident-sounding but incorrect statements).

  • Human-task specialist: Can dramatically improve success rates for fuzzy human tasks, but introduces new types of risk (confidently wrong answers, brittleness with edge cases).

Supporting evidence: Major AI systems (GPT-3[3], GPT-4[4], PaLM[5]) demonstrate strong few-shot learning capabilities; training techniques like reinforcement learning from human feedback[7] improve alignment with human preferences; advanced prompting methods like Chain-of-Thought reasoning[8][9] improve performance but affect speed and consistency. However, benchmarks like TruthfulQA[10] reveal limitations: even the best AI models achieve only 58% accuracy on truth-telling tasks compared to 94% human performance, with larger models often being less truthful.

Hypothesis to test: For human-language understanding tasks (intent extraction on messy inputs), an instruction-tuned LLM will achieve higher recall and higher end-to-end task success than a rule/grammar system but will have a higher rate of high-severity errors (e.g., misrouting, hallucinated facts).

Suggested metrics: precision/recall/F1, end-to-end task success rate, hallucination rate (annotated), failure severity taxonomy, inference cost per successful task.

3. The Fish and the Tree (Choosing the Right Tool)

"A fish is brilliant at swimming but terrible at climbing trees. Similarly, AI excels at human-like tasks but struggles with tasks requiring mathematical precision."

This metaphor captures a fundamental design principle: AI systems are optimized for pattern recognition in human-like domains (language, creative tasks, interpreting ambiguous inputs) but are misaligned for domains requiring provable correctness (financial calculations, security validations, compliance checks). This isn't a limitation to overcome—it's a design reality to work with.

Operational implication: For every AI use case, adopt the Claim → Hypothesis → Experiment → Decision pattern before deploying to production. This prevents costly failures and ensures you're using the right tool for each job.

4. Worked example: "Update every row of this CSV and properly quote all fields"

Plain observation (original): People ask an LLM to produce a script, and the model writes code — but the generated code can silently introduce subtle CSV bugs.

Data-driven rewrite:

Claim: "An LLM can produce a correct CSV-processing script."

Hypothesis: When given diverse CSV edge cases (embedded newlines, quotes, variable encodings), a hand-coded deterministic parser will produce substantially fewer silent correctness failures than an LLM-generated one.

Method: Assemble a held-out dataset of 2,000 CSV files representing edge cases. Measure: number of files processed correctly, percent of silently broken outputs, human time to repair, and catastrophic failures. Run paired comparisons: (A) deterministic library script, (B) LLM-generated script (same prompt), (C) LLM with deterministic test harness (validation layer).

Decision rule: If LLM + validator equals deterministic script on core correctness and reduces human effort by >X% without increasing catastrophic failure, adopt LLM+validator. Otherwise keep deterministic solution.

Why this test is useful: it converts the intuitive worry ("LLM might silently break CSVs") into measurable outcomes: silent failure rate and human repair cost.

5. Where each engine should be used — evidence blocks

For each pattern below I give a one-line hypothesis (to test), a short rationale grounded in the literature, and the primary metrics you should collect.

Deterministic

Data transformations, validations, compliance, database integrity, security boundaries.

Hypothesis: Deterministic solutions yield near-zero catastrophic failures on these tasks.

Metrics: catastrophic failure rate, regression frequency.

Probabilistic

Interpreting intent from messy text, summarization, creative generation, converting human requests to structured commands.

Hypothesis: LLMs improve end-to-end success on fuzzy tasks vs grammar-based systems when measured on human task completion.

Metrics: task success rate, human satisfaction, hallucination rate.

(Cited work: instruction tuning/RLHF[7], model cards & dataset reporting[11], RAG/plugin grounding[12], production patterns.)

6. An evolving, evidence-based framework (process)

For each architectural decision:

  1. Formulate hypothesis. (E.g., "LLM improves intent recall by ≥10% on our queries.")

  2. Design experiments. Choose datasets (production or synthetic), metrics, and significance tests. (Bootstrap/permutation tests are common for non-parametric comparisons.)

  3. Run offline evaluation. Compare deterministic vs probabilistic approaches; when evaluating LLMs, consider deterministic verification layers or human-in-the-loop options and annotate hallucinations and high-severity errors.

  4. Run pilot online / A/B test. Instrument fallbacks, latency, cost, and user satisfaction. Research shows that over two-thirds of organizations report 30% or fewer of their AI experiments will fully scale in the near term[23], making careful A/B testing crucial.

  5. Decide using pre-registered thresholds. E.g., only launch if catastrophic failure rate ≤ baseline and end-to-end success increases by ≥X. Consider that 74% of companies struggle to achieve tangible value from AI[21], often due to lack of clear success criteria.

  6. Operationalize: model cards[11], dataset cards, monitoring, human-in-the-loop thresholds, rollback playbooks.

Governance: Use Model Cards[11] and Datasheets to document intended use, limitations, and evaluation. Set SLOs for hallucination/failure rates and create automated alerts on drift or spikes.

Production monitoring (2024 best practices): Monitor model performance metrics (AUC, precision, recall) alongside proxy metrics like data distribution drift. Implement fallback strategies including alternative models, human-in-the-loop decision making, and automatic model rollback when performance drops below thresholds. Design sustainable monitoring that balances accuracy with energy efficiency in drift detection systems[19]. Note that AI incident reports increased 56.4% in 2024 to 233 incidents[22], emphasizing the critical importance of robust monitoring[17].

7. Cost Considerations: Probabilistic vs Deterministic Solutions

When both approaches can solve a task identically, cost becomes a critical decision factor. Here's how they compare:

AI Model Costs (2024 Data)

Current LLM Pricing (as of late 2024/early 2025):

  • GPT-4o: $2.50 input / $10.00 output per million tokens (OpenAI official pricing)[25]

  • Claude 3.5 Sonnet: $3.00 input / $15.00 output per million tokens (Anthropic official pricing)[30]

  • Small models: As low as $0.07 per million tokens (various providers)[26]

Note: Pricing changes frequently; these numbers reflect current rates at time of publication.

Dramatic Cost Reductions: The cost of GPT-3.5-level performance dropped from $20 per million tokens (November 2022) to $0.07 per million tokens (October 2024)—a 280-fold reduction in 18 months[22]. For some benchmarked tasks, LLM inference costs have dropped by 1,000x in just 3 years, with current decline rates of 9-900x per year depending on task complexity[22].

Deterministic Algorithm Costs (2024 Data)

Dedicated Server Computing (AWS EC2 Reserved Instances):

  • Cost-effective instances: $50-200/month for general-purpose compute[27]

  • High-performance options: $300-800/month for compute-optimized instances[27]

  • Per-execution cost: Near-zero marginal cost for high-volume deterministic workloads[27]

Cost Decision Framework

When Deterministic Wins:

  • High-volume, simple tasks: Processing millions of records where cost difference can be substantial

  • Real-time requirements: Deterministic algorithms avoid per-token latency and costs

  • Predictable workloads: Fixed infrastructure costs vs variable token consumption

When AI Wins:

  • Complex interpretation tasks: Lower per-inference cost compared to engineering custom deterministic systems

  • Adaptive requirements: AI handles edge cases without extensive custom code development

  • Human-like tasks: Natural language processing, content creation, customer service interactions

Note: Specific cost thresholds vary significantly by use case, scale, and implementation requirements.

Total Cost of Ownership Considerations

Beyond per-task costs, consider:

  • Development time: Varies significantly by task complexity and implementation requirements

  • Maintenance: Deterministic code requires ongoing updates; AI models require expensive retraining, data collection, and safety evaluation cycles

  • Talent costs: Multiple US salary aggregators generally show ML engineer median salaries around 5-20% higher than comparable software engineers[28]

  • Infrastructure: AI workloads require GPU compute ($1.85-$8.00/hour for high-end GPUs)[29] vs standard CPU servers

  • Monitoring: AI requires drift detection and safety monitoring; deterministic systems need standard observability

Projection: If current trends in model pricing continue while CPU compute costs remain relatively stable, the cost advantage is likely to increasingly favor AI solutions over time.

8. Closing thought

AI expands computing with enormous potential. But to make high-leverage, low-risk decisions at the team level we must replace "AI feels right" with concrete, reproducible evidence. This document shows how: map claims → hypotheses → experiments → metrics → decisions.

Appendix A — Suggested experiments & visualizations (practical checklist)

Per-claim experiment template

  • Dataset: 1,000–5,000 labeled examples drawn from production + synthetic edge cases.

  • Variants: Deterministic, LLM (instruction-tuned), LLM with deterministic verification (validator), human baseline.

  • Metrics: precision/recall/F1, end-to-end success, hallucination rate (manual annotation), cost/latency per successful request, failure severity distribution.

  • Visualizations: precision-recall curves, confusion matrices, cost vs accuracy plots, stacked bar of failure severities, time series for drift.

Monitoring/telemetry to ship

  • Human fallback rate per 1k requests

  • Hallucination spikes (annotated sample + metric)

  • Latency percentiles (p50/p95/p99) and cost per 1k requests

  • Regression detection: automated unit tests + shadow runs after model updates

Appendix B — Annotated bibliography (prioritized, 2020–2025)

How to use this bibliography: start with the highlighted "must read" items (ML systems engineering and a recent LLM technical report), then read the assessment and hallucination papers and finally the production playbooks and MLOps resources.

Foundational Systems Perspective

  • Sculley et al., "Hidden Technical Debt in Machine Learning Systems" (2015)[1] — foundational systems perspective on how ML adds ongoing engineering costs; frames the need for measurement and observability. (Classic, still essential.)

Core LLM Capability Papers

  • Brown et al., "Language Models are Few-Shot Learners" (GPT-3, 2020)[3] — describes scaling and few-shot behavior that propelled modern LLM productization.

  • OpenAI, "GPT-4 Technical Report" (2023)[4] — product-level analysis of capabilities, limitations, safety evaluation, and red-teaming; useful template for evaluation.

  • Chowdhery et al., "PaLM: Scaling Language Modeling with Pathways" (Google, 2022)[5] — industrial scaling and evaluation, useful for thinking about performance/cost tradeoffs.

  • Touvron et al., "LLaMA / LLaMA 2" (Meta, 2023)[6] — open-model design choices and practical evaluation for cost-effective large models.

Alignment and Training Methods

  • OpenAI, "Training language models to follow instructions with human feedback" (InstructGPT, 2022)[7] — RLHF/instruction tuning workflows showing 1.3B parameter model outperformed 175B GPT-3 on human preferences.

  • Anthropic, "Constitutional AI" (2022)[13] — alternative approach to model alignment using high-level rules and automated critique.

Reasoning and Tool Use

  • Wei et al., "Chain-of-Thought Prompting Elicits Reasoning in Large Language Models" (2022)[8] — technique emerging at ~100B+ parameter scale, achieving state-of-the-art on GSM8K math problems with 540B model.

  • Wang et al., "Self-Consistency" (2022/2023)[9] — method to stabilize chain-of-thought outputs by aggregating multiple reasoning paths.

  • Yao et al., "ReAct: Synergizing reasoning and acting" (2022)[12] — combines reasoning and tool use to produce grounded, interactive behavior.

Evaluation and Benchmarking

  • Lin et al., "TruthfulQA" (2022)[10] — benchmark of 817 questions across 38 categories to measure hallucination and truthfulness, finding best models achieve 58% vs 94% human accuracy.

  • Liang, Bommasani et al., "Holistic Evaluation of Language Models" (TMLR 2023)[14] — framework for measuring capability, robustness, fairness, and efficiency across 16 scenarios and 7 metrics.

  • Srivastava et al., "Beyond the Imitation Game" (BIG-Bench, 2022)[31] — large, diverse task suite of 204 tasks for stress-testing models.

Production and Safety

  • OpenAI / Anthropic / Google engineering & safety posts (2021–2024) — real-world descriptions of red-teaming, safety practices, and deployment lessons.

  • Peng et al., "The Impact of AI on Developer Productivity: Evidence from GitHub Copilot" (2023)[32] — controlled experiment showing 55.8% faster task completion with AI pair programming.

  • Nakano et al., "WebGPT: Browser-assisted question-answering" (2021)[33] and Schick et al., "Toolformer" (2023)[34] — approaches to grounding generation in external tools or retrieved knowledge.

Documentation and Governance

  • Model Cards (Mitchell et al.)[11] & Datasheets for Datasets (Gebru et al.) — templates for reporting model capabilities and dataset provenance.

  • Data-Centric AI Workshop (Andrew Ng et al., NeurIPS 2021)[35] — focus on datasets and repeatable evaluation to improve model performance.

Recent Developments (2024-2025)

  • OpenAI o1 System Card (2024)[15] — breakthrough reasoning model with extensive safety evaluation and red-teaming; demonstrates improved chain-of-thought capabilities but also concerning deceptive behaviors.

  • Claude 3 Model Card (2024)[16] — Anthropic's flagship multimodal model with enhanced constitutional AI training and safety features.

  • AI Safety Index 2025[17] — comprehensive analysis of AI safety practices, governance frameworks, and risk management approaches.

  • Apollo Research deceptive behavior study (2024)[18] — evaluation of frontier AI models showing concerning scheming capabilities in o1 and other advanced models.

  • Sustainable ML monitoring research (2024)[19] — addressing energy efficiency tradeoffs in concept drift detection for production systems.

Industry Surveys and Deployment Data (2024)

  • McKinsey State of AI 2024[20] — comprehensive survey of AI and gen-AI adoption, value capture, and organizational challenges. Stanford's AI Index 2025[22] reports that 78% of organizations used AI in 2024.

  • Boston Consulting Group AI Value Study (2024)[21] — reveals only 26% of companies generate tangible value from AI at scale, with 74% struggling to move beyond proof-of-concept.

  • Stanford HAI AI Index 2025[22] — documents 56.4% increase in AI incidents to 233 total incidents in 2024, indicating growing deployment risks.

  • Deloitte State of GenAI Enterprise Survey Q4 2024[23] — over two-thirds of respondents report 30% or fewer of their GenAI experiments will fully scale.

  • NTT DATA GenAI ROI Analysis (2024)[24] — comprehensive study showing 70-85% of generative AI deployments fail to meet desired return on investment.

Appendix C — Mapping claims ↔ citations ↔ experiments (example)

Claim: "AI excels at interpretation."

Citations: GPT-3 (Brown et al., 2020)[3], PaLM (Chowdhery et al., 2022)[5], InstructGPT (OpenAI, 2022)[7].

Experiment: Label 2,500 production messy queries for gold intents; measure LLM recall/precision vs grammar parser; bootstrap test for significance.

Claim: "Most AI deployments fail to scale."

Citations: Boston Consulting Group (2024)[21] finding 74% struggle to achieve value; Deloitte (2024)[23] finding over two-thirds report 30% or fewer experiments scale; NTT DATA (2024)[24] documenting 70-85% ROI failure rates.

Experiment: Track 100 AI pilot projects for 18 months; measure success rates by project type, organization size, and implementation approach.

Claim: "AI introduces new maintenance costs."

Citations: Sculley et al. (2015)[1]; sustainable ML monitoring research (2024)[19]; AI incident increase data (Stanford HAI, 2025)[22].

Experiment: Instrument team maintenance time across deterministic vs LLM features for 3 months; measure mean time to detect, mean time to repair, ongoing cost, and incident response overhead.

References

  1. Sculley, D., et al. (2015). Hidden Technical Debt in Machine Learning Systems. NeurIPS. Link

  2. OpenAI/Anthropic/Google production reports (2021-2024). Various engineering & safety posts describing real-world deployment lessons and red-teaming practices.

  3. Brown, T., et al. (2020). Language Models are Few-Shot Learners. NeurIPS. arXiv

  4. OpenAI. (2023). GPT-4 Technical Report. arXiv preprint. arXiv

  5. Chowdhery, A., et al. (2022). PaLM: Scaling Language Modeling with Pathways. arXiv preprint. arXiv

  6. Touvron, H., et al. (2023). LLaMA: Open and Efficient Foundation Language Models. arXiv preprint. arXiv

  7. Ouyang, L., et al. (2022). Training language models to follow instructions with human feedback. NeurIPS. arXiv

  8. Wei, J., et al. (2022). Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. NeurIPS. arXiv

  9. Wang, X., et al. (2022). Self-Consistency Improves Chain of Thought Reasoning in Language Models. ICLR. arXiv

  10. Lin, S., Hilton, J., & Evans, O. (2022). TruthfulQA: Measuring How Models Mimic Human Falsehoods. ACL. arXiv

  11. Mitchell, M., et al. (2019). Model Cards for Model Reporting. FAT. arXiv

  12. Yao, S., et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models. ICLR. arXiv

  13. Bai, Y., et al. (2022). Constitutional AI: Harmlessness from AI Feedback. arXiv preprint. arXiv

  14. Liang, P., Bommasani, R., et al. (2023). Holistic Evaluation of Language Models. Transactions on Machine Learning Research. arXiv

  15. OpenAI. (2024). OpenAI o1 System Card. OpenAI Technical Report. Link

  16. Anthropic. (2024). Claude 3 Model Card. Anthropic Technical Report.

  17. Future of Life Institute. (2025). AI Safety Index 2025. FLI Safety Report. Link

  18. Apollo Research. (2024). Frontier AI Models Show Concerning Deceptive Behavior in Safety Evaluations. Apollo Research Report.

  19. Wang, L., Chen, X., Zhang, Y., et al. (2024). How to Sustainably Monitor ML-Enabled Systems? arXiv preprint. arXiv

  20. McKinsey. (2024). The state of AI in early 2024: Gen AI adoption spikes and starts to generate value. McKinsey Global Survey. Link

  21. Boston Consulting Group. (2024). AI Adoption in 2024: 74% of Companies Struggle to Achieve and Scale Value. BCG Survey Report. Link

  22. Stanford HAI. (2025). AI Index 2025: State of AI in 10 Charts. Human-Centered AI Institute Report. Link

  23. Deloitte. (2024). State of Generative AI in the Enterprise Q4 2024. Deloitte AI Institute Survey. Link

  24. NTT DATA. (2024). Between 70-85% of GenAI deployment efforts are failing to meet their desired ROI. Enterprise AI Study. Link

  25. OpenAI. (2024). OpenAI API Pricing. Official OpenAI Pricing Documentation. Link

  26. Various LLM providers. (2024). Small model pricing comparison across providers. Aggregate pricing data from multiple LLM API providers.

  27. Amazon Web Services. (2024). EC2 Instance Pricing and Reserved Instances. AWS Official Pricing Documentation. Link

  28. DataCamp/Glassdoor. (2024). Machine Learning Engineer vs Software Engineer Salary Comparison. 2024 Salary Survey Data.

  29. GMI Cloud/Lambda/CoreWeave. (2024). GPU Cloud Pricing Comparison for AI Workloads. AI Infrastructure Pricing Analysis. Link

  30. Anthropic. (2024). Claude API Pricing. Official Anthropic Pricing Documentation. Link

  31. Srivastava, A., et al. (2022). Beyond the Imitation Game: Quantifying and extrapolating the capabilities of language models. Transactions on Machine Learning Research. arXiv

  32. Peng, S., et al. (2023). The Impact of AI on Developer Productivity: Evidence from GitHub Copilot. arXiv preprint. arXiv

  33. Nakano, R., et al. (2021). WebGPT: Browser-assisted question-answering with human feedback. arXiv preprint. arXiv

  34. Schick, T., et al. (2023). Toolformer: Language Models Can Teach Themselves to Use Tools. arXiv preprint. arXiv

  35. Ng, A., et al. (2021). Data-Centric AI Workshop. NeurIPS 2021. Link