IdeaWell

Project ideas from Hacker News discussions.

Coding is not solved

Original Article

Hacker News Discussion

📝 Discussion Summary (Click to expand)

5 Prevalent Themes in the HN Discussion on "Is Coding Solved?"

  1. Coding ≠ Software Engineering
    Many argue LLMs handle basic code generation ("coding") but not higher-level software engineering (design, architecture, planning).

    "LLMs even a version number or two ago can write all the code I've ever been paid to write in the last 20 years; but they are not, I think, yet competent enough to be able to handle the project planning and self-QA I was doing even in my first 6 months of my first job after graduating." (ben_w)
    "The idea that 'coding' is just turning a spec into source code without any engineering decisions to be made was always laughable." (flohofwoe)

  2. Code Quality and Reliability Concerns
    Widespread skepticism about AI-generated code's robustness, citing hidden bugs, technical debt, and eroded trust.

    "The promised scalability improvements did not materialize. Instead, it got worse. Observability had been lost. The telemetry was no longer trustworthy." (bunderbunder)
    "What I've found is that AI allows lazy and incompetent developers to be more lazy and more incompetent. This then has the effect that product quality suffers more, faster." (askonomm)

  3. Accountability Gap
    LLMs cannot be held responsible for errors; humans must retain accountability, but some feel this is being avoided.

    "The main point of the article is accountability and that's not something we can delegate to AI." (hanifbbz, author)
    "AI cannot be held accountable. It cannot suffer any consequences. [...] You cannot punish AI, therefore it can never be held accountable." (jstummbillig)

  4. Productivity vs. Quality Trade-off
    While LLMs boost output speed, critics argue this often sacrifices long-term maintainability and correctness.

    "This article would be 100% correct if it came out 1 year ago, 75% correct 9 months ago, 50% correct 3 months ago and it's probably 25% correct now if not less." (temp00345)
    "I’ve found that if I do even 3 months of pure agentic coding with no code reviews, it’s aged 10x faster than a human coded codebase." (an0malous)

  5. Evolving Developer Role
    The programmer's job is shifting from writing code to guiding, verifying, and contextualizing AI output.

    "I provide AI with valuable context such as code coverage information, architecture analysis, test requirements... I'm still very much the person who comes up with the solutions." (ben_w)
    "The New Skill of software engineering: can you steer agents well enough to get work done at the speed they will allow, while still keeping enough context/understanding to step in when it matters?" (ketzo)

🚀 Project Ideas

Deterministic AI Code Verifier

Summary

  • A sandbox service that runs AI-generated code through formal verification, property-based testing, and mutation testing to ensure deterministic correctness before merging.
  • Core value proposition: guarantees that AI-produced code meets specifications with mathematical confidence, eliminating guesswork in code reviews.

Details

Key Value
Target Audience Enterprise developers, platform teams, and AI-assisted development squads
Core Feature Automated verification pipeline that accepts LLM output only after passing exhaustive property tests, fuzzing, and formal checks
Tech Stack Rust (verification engine), Python (test generation), WASM sandbox, GitHub Actions integration
Difficulty High
Monetization Revenue-ready: tiered SaaS based on verification minutes ($0.001 per CPU-minute)

Notes

  • HN commenters complained about AI nondeterminism and unreliable outputs; this directly addresses those concerns by providing provable guarantees.
  • Enables teams to trust AI agents in safety-critical domains (finance, healthcare) where deterministic behavior is required.

AI Agent Change Impact Monitor

Summary

  • Continuously monitors AI agent outputs for undocumented breaking changes, automatically generates impact reports, and suggests version bumps or documentation updates.
  • Core value proposition: prevents silent regressions from AI tool updates by making changes visible and actionable before they affect downstream consumers.

Details

Key Value
Target Audience DevOps teams, platform engineers, and maintainers of AI-driven dev tools (e.g., Copilot, CodeX)
Core Feature Diff‑analysis engine that compares agent‑generated code across versions, flags API/behavioral shifts, and auto‑creates changelogs
Tech Stack Go (analysis), PostgreSQL (metadata), GraphQL API, React dashboard
Difficulty Medium
Monetization Revenue-ready: per‑repository pricing ($10/mo repo) + enterprise audit logs

Notes

  • Commenters highlighted that AI agents push breaking changes without notice, causing wasted debugging time; this tool surfaces those changes automatically.
  • Encourages better hygiene in AI‑powered tooling ecosystems, a frequent pain point in the thread.

Accountability Ledger for AI‑Generated Code

Summary

  • Immutable ledger that logs every AI‑generated code snippet, its prompting context, model version, and required human approvals before it reaches production.
  • Core value proposition: establishes clear accountability and traceability for AI contributions, satisfying legal and compliance needs.

Details

Key Value
Target Audience Compliance officers, tech leads, and regulated‑industry engineering teams
Core Feature Append‑only log (blockchain‑style) tied to PRs, enforceable via branch protection rules, with audit‑trail UI
Tech Stack Rust (ledger), IPFS (storage), smart contract (optional), webhook‑based CI integration
Difficulty Medium
Monetization Revenue-ready: subscription per active developer ($5/dev/mo) + enterprise compliance packages

Notes

  • The discussion repeatedly stressed that LLMs cannot be held accountable; this ledger makes humans (or their organizations) the accountable party.
  • Provides the “implied social contract” mentioned by commenters, turning vague concerns into enforceable processes.

Spec‑to‑Test Generator for AI Code

Summary

  • Takes natural‑language feature specifications and automatically produces exhaustive property‑based and fuzz test suites that validate AI‑generated implementations without manual test writing.
  • Core value proposition: shifts verification from brittle example‑based tests to comprehensive behavioral guarantees, reducing reliance on human test authors.

Details

Key Value
Target Audience QA engineers, backend teams, and any group using LLMs for code generation
Core Feature NL‑spec parser → Hypothesis/QuickCheck style property tests + AFL‑style fuzz harnesses, integrated into CI
Tech Stack TypeScript (spec parser), Rust (property‑test engine), Docker (fuzz runners), GitHub Actions
Difficulty High
Monetization Revenue-ready: pay‑per‑generated‑test‑suite ($0.10 per 1k properties) + team plans

Notes

  • Commenters noted that AI can pass shallow unit tests while hiding logical flaws; this approach validates behavior across the input space.
  • Directly supports the “show me the tests” mindset advocated by several HN users who distrust AI without rigorous verification.

Deterministic Agent Orchestration Framework

Summary

  • A framework that enforces deterministic LLM agent loops via prompt caching, versioned tooling, and replayable execution, ensuring identical inputs yield identical outputs.
  • Core value proposition: eliminates stochastic variability in agentic workflows, making AI‑assisted development reproducible and debuggable.

Details

Key Value
Target Audience Platform engineers building AI‑agent pipelines, startups relying on agentic coding
Core Feature Execution engine that logs prompts, tool calls, and model snapshots; provides deterministic replay and diff‑based debugging
Tech Stack Python (orchestration), Redis (cache), SQLite (execution log), gRPC agent interface
Difficulty Medium
Monetization Revenue-ready: hosted service with free tier, paid plans based on orchestration hours ($0.05/hr)

Notes

  • Many commenters criticized AI’s non‑determinism and the difficulty of reproducing results; this framework gives them control.
  • Enables teams to treat agents as reliable components rather than black‑box random generators, addressing the “trust but verify” sentiment.

Read Later