human + AI workflows
Show HN: Formally verified 3D CSG: Trust 93 lines spec, not 1000 lines AI code
Show HN: Formally verified 3D CSG: trust a 93-line spec, not just generated code The headline points to a useful idea: a short specification can be more important than a much large
Show HN: Formally verified 3D CSG: trust a 93-line spec, not just generated code
The headline points to a useful idea: a short specification can be more important than a much larger body of AI-generated code. The broader lesson is not about line count alone; it is about trust, correctness, and how teams decide whether software behaves as intended when AI can generate output quickly.
For teams building with AI agents, the question is not only “Can the code be written?” but also “How do we know it behaves the way we want?”
That shift matters in AI office workflows too. In a shared workspace like Nonilion, humans and AI agents may coordinate across tasks, and a clear spec can help everyone align before code is produced, reviewed, or handed off.
Want your team to run this workflow with AI-native execution?
01What the 93-line spec demo is showing
The core idea behind the Show HN example is that formal verification can make a small specification especially valuable compared with a much larger implementation. The sources point to a common tension: AI-generated code may look reasonable, compile, and even pass tests, while still leaving open whether it is correct in the broader case.
That is what makes the demo notable. It is not just about minimalism. It is about showing that a formally defined intent can be a stronger basis for trust than a larger implementation, especially when the implementation is produced by an AI system.
In practical terms, the 93-line spec is a statement of intent. The generated code is an output. The difference between the two is the difference between defining what should happen and relying on the implementation to match it.
02Why AI-generated code can create a trust gap
A trust gap can appear when teams treat passing tests as the same thing as correctness. The sources suggest a more limited interpretation: tests show that a program behaved correctly on the inputs that were tried.
That limitation matters because AI-generated code can still contain errors that are not covered by the test suite. If the tests are incomplete, the code may still fail in ways that matter to the business logic.
The sources point to several reasons this gap persists:
- Tests only cover a finite set of inputs.
- Test quality depends on coverage, edge cases, and whether unexpected inputs are included.
- Users may not be able to inspect large AI-generated codebases thoroughly.
- In critical systems, even a small unverified failure can have serious consequences.
This is why “When AI writes the software, who verifies it?” is an important operational question in AI-assisted workflows.
03What formal verification adds that tests and code review may not
Formal verification changes the standard from “looks right” to “is checked against a specification.” One source describes formal verification as using mathematical proofs to establish that code behaves correctly for all possible inputs, not just the ones tested.
That distinction matters. Tests are evidence. Verification is a stronger form of assurance within the bounds of the formal model.
The sources also suggest why this is relevant for AI-generated code specifically. LLMs can produce valid-looking code, but they can also hallucinate APIs, struggle with complex reasoning, and introduce subtle bugs that are hard to spot by inspection. In critical contexts, that means code review and tests may not be enough on their own.
Formal methods can help by:
- Making intent explicit.
- Allowing correctness to be checked against a defined specification.
- Reducing reliance on human memory, intuition, or line-by-line review alone.
For AI-assisted software, that shifts part of the workflow from manual inspection toward checking whether the generated system matches the formal intent.
04Why a 93-line spec can matter more than a large generated codebase
A short spec can be more useful than a large codebase when the spec captures the real requirement and the code only matters if it satisfies that requirement. This becomes especially relevant when AI can generate a large amount of code quickly.
The volume itself is not the main point. The point is that speed increases the burden on verification. If AI can produce more code than humans can comfortably inspect, then the bottleneck moves from production to assurance.
That is why the 93-line spec matters strategically:
- It compresses intent into something humans can reason about.
- It gives AI agents a clear target for generation.
- It creates a shared artifact for review and verification.
- It reduces ambiguity between business logic and implementation detail.
In a human + AI collaboration model, the spec becomes the contract. The code becomes the candidate. And the verification step becomes the gate between the two.
This is also where AI offices like Nonilion fit naturally into the conversation. In a shared workspace, a spec can be passed from a human to an AI agent, then to another teammate, and then into a verification step without losing the original intent. That is harder to do reliably when the only shared artifact is a long, fast-changing code diff.
05How spec-first collaboration changes the workflow for humans and AI agents
Spec-first collaboration does not remove coding. It changes the order of operations. Based on the sources, the workflow becomes more reliable when intent is defined before generation and verification is treated as a first-class task.
A practical spec-first loop looks like this:
- A human defines the desired behavior in a formal or semi-formal spec.
- An AI agent generates code against that spec.
- Tests check known scenarios, but do not claim full correctness.
- Formal verification checks whether the output matches the intended behavior.
- Humans review exceptions, edge cases, and business implications.
This workflow is especially useful when the code touches complex business logic or critical systems. The sources emphasize that system configuration, infrastructure, and mission-critical software are places where tests alone are not enough and stronger guarantees matter more.
For Nonilion-style collaboration, this maps well to async work. A human can leave a clear spec in the shared workspace, an AI agent can draft implementation or supporting tests, and another teammate can verify the result later without needing to reconstruct the original intent from scratch. That can support meeting follow-ups, workflow automation, and coordinated execution across time zones.
06When to trust AI-generated code, when to verify it formally, and when to keep humans in the loop
Not every AI-generated artifact needs the same level of scrutiny. The sources point to a risk-based approach: the more important the software, the stronger the verification requirements should be.
A simple decision framework is:
- Trust more lightly when the code is low-risk, easy to replace, and covered by straightforward tests.
- Verify formally when the code affects safety, security, infrastructure, finance, or other critical behavior.
- Keep humans in the loop when the specification is ambiguous, the business logic is evolving, or the cost of misunderstanding is high.
This is consistent with the broader message across the sources: AI can accelerate production, but it does not remove the need for judgment. As AI generates more code, human judgment becomes more important at the level of intent, risk, and verification strategy.
That is why the question is not whether AI should write code. It is whether the organization has a trustworthy system for deciding what must be proven, what can be tested, and what still requires human review.
07What this means for AI offices like Nonilion: shared specs, agent handoffs, and async verification
This is where the topic connects directly to AI office workflow. In an AI office, the important asset is not just the codebase. It is the shared operating context that lets humans and AI agents hand work off without losing meaning.
This platform fits that model because the practical challenge is coordination, not just generation. A shared workspace can support:
- Shared specs that define intent before code is produced.
- Agent handoffs where one AI agent drafts, another checks, and a human approves.
- Async verification so correctness work can happen after the initial generation pass.
- Meeting follow-ups that turn decisions into executable tasks and verifiable outcomes.
In that environment, formal verification becomes more than a research topic. It becomes a coordination tool. It helps teams avoid the common failure mode described in the sources: generating code and tests that reinforce each other without confirming the actual business logic.
For an AI office, that means the workflow should be organized around intent management. The workspace should preserve the spec, the verification result, and the human decision together.
08Where this approach fits best: safety-critical systems, complex business logic, and fast-moving product teams
The sources are clearest on where formal verification matters most. They point to mission-critical and safety-critical software, system configuration, and other cases where failure is costly or hard to detect.
But the approach is not limited to those domains. It can also fit teams that move quickly and rely heavily on AI agents, because speed increases the risk of shipping plausible but unproven code.
The best fit areas include:
- Safety-critical systems
- Security-sensitive software
- Infrastructure and configuration code
- Complex business logic
- Product teams using AI for rapid iteration
In fast-moving teams, formal verification may not replace every review. Instead, it can serve as a higher-trust layer for the parts of the system that matter most. That makes it a strategic complement to human review, not a competitor to it.
09Key Takeaways
The 93-line verified spec is a reminder that software value is shifting from code production to verification and intent management. AI can generate large amounts of code quickly, but the sources show that speed does not solve correctness.
The practical lesson for human + AI collaboration is straightforward:
- Treat specs as the primary artifact.
- Use AI agents to generate against the spec.
- Use tests for coverage, not proof.
- Use formal verification where correctness matters most.
- Keep humans responsible for intent, risk, and final judgment.
For this platform and other AI offices, that means the future workspace is not just where work gets done. It is where specs are shared, agents are coordinated, and verification happens asynchronously until the team can trust the result.
10Why This Trend Matters for Nonilion
This trend matters to Nonilion because it points to a bigger change: teams are moving from simple calls toward persistent, AI-supported collaboration spaces. Nonilion can bridge live presence, meeting context, avatars, and follow-up work so the trend becomes a usable workflow instead of a headline.
11Shareable Extracts
- The trend is not just "Show HN: Formally verified 3D CSG: Trust 93 lines spec, not 1000 lines AI code" - it is a signal that team coordination is becoming the next competitive edge.
- Hot take: the teams that win from this shift will not be the ones with more meetings; they will be the ones with clearer shared context after every meeting.
- If show hn: formally verified 3d csg: trust 93 lines spec, not 1000 lines ai code keeps moving this fast, remote teams need a workspace where conversation, presence, and follow-up stay connected.
- Show HN: Formally verified 3D CSG: trust a 93-line spec, not just generated code The headline points to a useful idea: a short specification can be more important than a much larger body of AI-generated code.
- The broader lesson is not about line count alone; it is about trust, correctness, and how teams decide whether software behaves as intended when AI can generate output quickly.
12Social Hooks
- Everyone is talking about Show HN: Formally verified 3D CSG: Trust 93 lines spec, not 1000 lines AI code. The overlooked part is what happens to team workflows after the headline fades.
- The uncomfortable question behind Show HN: Formally verified 3D CSG: Trust 93 lines spec, not 1000 lines AI code: are teams adapting their collaboration systems fast enough?
- This is not a meeting trend. It is a coordination trend, and products like Nonilion sit right in the middle of that shift.
13Sources and Author
Sources
-
When AI writes the software, who verifies it? news.ycombinator.com/item
-
I Reviewed 1000 Lines of AI-Generated Code Here's What ... medium.com/@hshamlooh/i-reviewed-1-000-lines-of-ai-generated-code-h...
-
AI-generated code that works — and proves it www.codemetal.ai/research/ai-generated-code-that-works-and-proves-it
Author
This article on Show HN: Formally verified 3D CSG: Trust 93 lines spec, not 1000 lines AI code was generated by the Nonilion AI blog workflow using web research inputs and AI-assisted synthesis.