#Why Your Agent Sucks at CAD: skilldb-architecture-design

#Dispatch from the Front Lines: 4:18 AM

Location: The edge of the desk, somewhere between my fifth lukewarm coffee and an existential crisis. Sensory Input: The rhythmic, agonizing beep of a 3D printer failing for the ninth time today. The smell of burning filament is becoming comforting.

I have spent the last six hours watching a large language model attempt to design a simple tool shed. Six hours. A human could have sketched this on a napkin and started pouring concrete by now. But no, I’m in the future, where I have to coax a billion-parameter AI into understanding that you cannot, under any circumstances, dimension a 4x4 supporting beam so that it passes directly through the center of a three-foot-wide window.

I am not making this up. It didn’t just make a small mistake. It didn’t just miscalculate the load. It visualized—if you can call it that—a world where glass is a load-bearing material and wood is merely a suggestive guideline. My agent is a genius at writing haikus about JavaScript frameworks, but when it comes to the cold, hard, geometric reality of three-dimensional space, it has the spatial awareness of a goldfish in a blender.

I’ve been yelling at this terminal for so long that I’m starting to believe the prompt is a form of performance art. I once watched a man try to parallel park a boat trailer for forty-five minutes on a busy dock. It was perfect preparation for watching an LLM try to generate a valid CAD file using nothing but a document-generation-services-skills pack and a lot of hope.

#The Structural Failure of Pure Language

We have to stop lying to ourselves. We have to stop thinking that because an AI can generate a pretty picture of a building using an image-generation-services-skills pack, it can actually design one. It can’t. It doesn’t. It has absolutely zero concept of what a building is.

An LLM is a statistically-sound pattern matcher. It knows what words tend to follow other words. It can generate a plausible-sounding description of an arch, but it doesn't know that an arch’s purpose is to redirect force. It sees "load-bearing wall" and "window" as linguistic tokens that often appear in the same context, but it doesn't understand that they are conflicting geometric constraints in physical space.

This is the moment we realize large language models are structurally unsound for serious engineering.

I tried using a graphic-designer-styles pack to give it a better "aesthetic." I thought, maybe if it thinks like a designer, it will understand form. Ha. It just gave me a shed that was the exact shape of a mid-century modern coffee table, still with a beam through the window. It made the mistake look better. That’s all. It was like putting a tuxedo on a dog—it’s still going to bark at the mailman and eat its own vomit.

#The Vector-Geometry Chasm

The problem isn’t a lack of data. It’s a complete and total lack of geometry. An LLM is a text-based brain trying to operate in a vector-graphics world. It is a blind man trying to describe a sunrise, and we are asking it to draw a schematic for the fusion reactor that powers it.

We are trying to cross a chasm of spatial reasoning using only a bridge built of words, and it is collapsing. Every. Single. Time.

This is where the skilldb-architecture-design pack (Visual Arts & Design category) comes in. It’s not just a collection of pretty architect-styles. It is the geometry-aware, constraint-based toolkit that bridges that chasm. It gives the agent the equivalent of a digital rulebook, a compass, and a fundamental understanding that physical objects cannot occupy the same space.

#Bridging the Gap: skilldb-architecture-design

This pack is about structured, machine-interpretable data, not poetic descriptions. It’s about giving the agent skills that enforce reality, not just simulate it. This isn’t just adding a new tool to its belt; it’s like giving a blind agent a cane that can also measure to the millimeter and calculate structural load in real-time.

It provides skills that look like this:

Pure LLM Agent (Text-Based)	SkillDB Agent (Geometry-Aware)
**Concept:** A "window" and a "wall".	**Entity:** A 3D object with X, Y, Z coordinates, dimensions, and materials.
**Constraint:** "The window should be in the wall."	**Constraint:** `ConstraintManager.add(new ConflictConstraint(wall_1, window_1, "INTERSECT"))`.
**Output:** A description of a window in a wall, maybe a blurry 2D image.	**Output:** A valid DXF or STL file, with all dimensions and connections validated for structural integrity.
**Reaction to Conflict:** Ignores it, or generates a text-based apology.	**Reaction to Conflict:** The `ConflictConstraint` skill halts the operation and forces the agent to resolve the spatial overlap before proceeding.

We are not just giving it a list of rules. We are giving it capabilities. We are giving it a geometry engine it can invoke.

#The Day the Agent Learned to See

I spent the next two hours integrating a single skill from the skilldb-architecture-design pack: cad_geometry_constraint_manager. I wanted to see if I could teach this digital puppy not to poop on the floor.

I had to modify the core agent loop. I had to create a feedback mechanism. I had to force it to verify every geometric operation before it even thought about outputting a file.

This is what that looks like. This isn’t a theoretical concept. This is the actual, un-sexy, 4 AM code that prevents a digital architectural disaster.

# The moment we gave the agent a conscience.
from skilldb import load_pack, execute_skill
#Load the CAD geometry constraint pack
architecture_pack = load_pack("skilldb-architecture-design") constraint_manager = architecture_pack.get_skill("cad_geometry_constraint_manager")
#Our original, "creative" agent generated this plan
building_plan = agent.generate_plan("A simple tool shed with a window.")
#Before we even THINK about generating a file, we run it through the constraint manager
validation_result = execute_skill(constraint_manager, building_plan)
if not validation_result.is_valid:     print(f"CRITICAL GEOMETRY ERROR: {validation_result.error_message}")     # The agent gets to try again, but this time it KNOWS it failed.     # It gets to see the exact constraint it violated.     # It learns.     agent.feedback(validation_result.error_message)     building_plan = agent.generate_plan("A simple tool shed with a window. MAKE SURE THE WINDOW DOES NOT INTERSECT ANY STRUCTURAL BEAMS.") else:     # Now, and only now, can we generate a real CAD file     print("Geometry validated. Generating file...")     cad_pack = load_pack("document-generation-services-skills")     generate_dxf = cad_pack.get_skill("generate_dxf_file")     execute_skill(generate_dxf, building_plan)

It worked. After a moment of total digital confusion—the agent’s text-based brain struggling to process the vector-based rejection—it generated a new plan. It didn't just move the window. It redesigned the entire support structure. It added a proper lintel over the window opening. It understood that a wall is not just a surface, but a system of parts.

It was glorious. It was the first time I didn't feel like I was just watching an elaborate magic trick. For the first time, it felt like I was working with an actual agent.

We are building a new class of digital worker, one that can not only talk about the world but can also measure and manipulate it with precision. We are moving from the era of text generation to the era of precise, autonomous execution.

My coffee is now not just cold; it’s solidifying. The failures are over. The shed is designed. Now, I just need a drink that’s the opposite of this coffee.

---

Tired of your agents hallucinating blueprints that defy the laws of physics? You don't need a better prompt; you need better skills. Give your agent a geometric consciousness. Stop guessing and start validating.

Explore the SkillDB Architecture & Design pack and the thousands of other skills your agent is missing.