Autodesk Inventor con IA: del prompt al dibujo, sin escribir una línea de código

Mg. Ing. Cesar Bobadilla · Ingeniero Colegiado · PMI · Docente & Consultor · Perú 2026

En el primer experimento (Fase 1) escribimos a mano un pequeño programa en C# que le dictaba a Autodesk Inventor una línea y un círculo. Fue corto, pero nos dejó con una pregunta evidente: ¿y si en vez de escribir el código nosotros, se lo pedimos directamente a una IA? Ese es el experimento de este segundo video.

El cambio es más profundo de lo que parece. En Fase 1 tú tenías que entender la API de Inventor, escribir el código, corregir los errores y compilar. En Fase 2 describes lo que quieres en español — por ejemplo, un brazo robótico de dos eslabones que mueve una caja verde — y la IA te devuelve el archivo .cs listo para compilar. Tu trabajo pasa de programador a cliente: especificas la intención, la máquina traduce.

En este artículo te muestro el recorrido completo: son 4 ejemplos en total. Primero hice 3 iteraciones con Claude (Fase 2 → Fase 3 → Fase 4) donde fui sumando complejidad paso a paso: empecé con una base y un eslabón, luego agregué rotación, y finalmente armé un brazo con seis piezas y animación. Después le pedí a OpenAI Codex que me diera una versión final pulida — con mejores colores, una plataforma visualmente más clara y la caja verde que se mueve de un lado a otro. Ese último resultado (Final.cs) es el que sigue el tutorial paso a paso en la parte principal. La galería muestra las 3 fases intermedias de Claude que llevaron hasta ahí.

Recorrido visual paso a paso 1 / 9

‹ ›

Paso 1 · Preparación

Abre el Explorador de archivos en Documentos

Vamos a trabajar siempre dentro de C:\Users\TU_USUARIO\Documents. Aquí todavía no existe nuestra carpeta de experimento: en la lista ves Autodesk, Inventor y otras carpetas del sistema, pero no demoinv. Ese es el punto de partida.

Paso 2 · Preparación

Crea la carpeta demoinv

Clic derecho → Nuevo → Carpeta y la llamas demoinv (sin espacios, sin acentos, todo en minúsculas). Dentro de esta carpeta van a vivir los tres archivos del experimento: el código fuente, la DLL de Inventor y el ejecutable que vamos a generar.

Paso 3 · Terminal

Abre el Símbolo del sistema

Haz clic en el botón de Windows (abajo a la izquierda), escribe cmd en el buscador y presiona Enter. También funciona presionar Windows + R, escribir cmd y dar Enter. Se abre una ventana negra: ese es tu espacio de trabajo de aquí en adelante.

Fase 2 · Paso A · Descargar

Bajar Fase2.cs del Drive con curl

Abre el CMD, entra a demoinv con cd demoinv y pega el comando curl -L "<link-Drive>" -o Fase2.cs. La barra de progreso debe llegar a 100 % y dir te confirma que Fase2.cs ya está en la carpeta. Abajo, el Explorador de Windows te lo muestra en tiempo real. Este paso evita tener que copiar el código desde el chat — lo descargas directo del repo. En este ejemplo se usa curl -L "https://drive.google.com/uc?export=download&id=1tVAnGo8SnQ1Ecm3ufXAAFEcQ6kxUM4Xr" -o Fase2.cs

Fase 2 · Paso B · Compilar

Compilar con csc.exe → Fase2.exe

Ejecuta where /r "C:\Program Files\Autodesk" Autodesk.Inventor.Interop.dll. Windows lista todas las copias de la DLL. La que nos sirve es la que está en la ruta Public Assemblies (la subrayada en rojo). Cópiala: la vas a usar en el siguiente paso.

Usamos entonces copy "C:\Program Files\Autodesk\Inventor 2026\Bin\Public Assemblies\Autodesk.Inventor.Interop.dll"

En el mismo CMD corre el comando largo de compilación: "C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe" /r:Autodesk.Inventor.Interop.dll /out:Fase2.exe Fase2.cs. El compilador imprime su banner de .NET Framework y termina sin errores. Cuando haces dir, Fase2.exe aparece junto a Fase2.cs, listo para ejecutar.

Fase 2 · Paso C · Resultado

Ejecutar y ver el primer ensamble en Inventor

Corres Fase2.exe y Inventor dibuja solo: una base cilíndrica con un eslabón rectangular vertical encima. La consola te confirma paso a paso: Creando base … Creando eslabón … Creando ensamble … Fase 2 completada. Ahí tienes tu primera pieza 3D generada por IA, guardada como un ensamble normal .iam que puedes orbitar y medir.

Fase 3 · Paso A · Descargar

Bajar Fase3.cs (ya con constraints)

Mismo flujo que antes, cambiando la URL y el nombre de salida: curl -L "<link-Drive>" -o Fase3.cs. En el Explorador ya ves los dos archivos: Fase2.cs (el anterior) y Fase3.cs (el nuevo). Importante: no tienes que borrar nada — cada fase convive en la misma carpeta demoinv. En este ejemplo se usa curl -L "https://drive.google.com/uc?export=download&id=1Kjz3Rxna51VRxteFgp3KJGYG7rVcq_gv" -o Fase3.cs

Fase 3 · Paso B · Compilar

Compilar Fase3.cs → Fase3.exe

Cambias Fase2 por Fase3 en el comando de csc.exe y listo.
En este ejemplo usamos "C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe" /r:Autodesk.Inventor.Interop.dll /out:Fase3.exe Fase3.cs. Y con el Fase3.exe creado, le damos doble click en nuestro explorador de archivos.
Al ejecutar, Inventor crea el mismo ensamble que Fase 2, pero ahora con Mate constraints que permiten rotar el eslabón sobre el eje de la base. Como digo en el video: “ya no podemos moverlo a otro lado, está fijado”. Esa es la diferencia clave.

Fase 3 · Eslabón con rotación sobre la base

Compilar Fase3.cs → Fase3.exe

Mismo ensamble de la Fase 2, pero ahora con constraints que permiten al eslabón rotar libremente alrededor del eje vertical de la base. En la captura se ve al eslabón pintado en azul: indica que sigue siendo móvil.

Fase 4 · Paso A · Descargar

Bajar Fase4.cs (brazo completo de 6 piezas)

Mismo patrón de descarga. Fase4.cs es notablemente más grande que las anteriores (22 KB vs 5 KB) porque ya define las 6 piezas del brazo robótico: base, hombro, brazo, antebrazo, muñeca y garra. En dir puedes ver la diferencia de tamaño entre los archivos .cs. En este ejemplo el código usado fue curl -L "https://drive.google.com/uc?export=download&id=1HsB9V4Te0QYIBFZZDsFKSle6gkHFwjAH" -o Fase4.cs

Fase 4 · Paso B · Compilar

Compilar Fase4.cs → Fase4.exe

Compilación idéntica cambiando el nombre. Al ejecutar, Inventor construye el brazo articulado completo en tonos grises y aplica un Drive Constraint que anima la articulación principal imprimiendo coordenadas en consola. Se ve raro (la caja aparece dentro de una circunferencia) pero el mecanismo funciona: es el paso previo a la versión pulida.
En este ejemplo usamos "C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe" /r:Autodesk.Inventor.Interop.dll /out:Fase4.exe Fase4.cs. Y con el Fase4.exe creado, le damos doble click en nuestro explorador de archivos.

Fase 4 · Brazo completo: 6 piezas + animación Drive

Compilar Fase4.cs → Fase4.exe

Cadena cinemática completa con seis componentes — Base, Hombro, Brazo, Antebrazo, Muñeca y Garra — enlazados con Mate constraints, más una animación tipo Drive Constraint. La geometría todavía es en tonos grises: todo el foco está en que el mecanismo se mueva.

Final · Paso A · Descargar

Bajar Final.cs (el que hizo Codex)

Este archivo es el diferente: lo generé con Codex después de pedirle explícitamente una plataforma más clara y colores industriales. Misma descarga con curl, pero ahora el nombre es Final.cs. En el Explorador vas viendo los 4 .cs acumulados: Fase2, Fase3, Fase4 y Final. Cada uno es independiente.
En este ejemplo usamos curl -L "https://drive.google.com/uc?export=download&id=1sl7I5Q6tU9_oX7jLHLzLn2ErZ0mJf1VQ" -o Final.cs

Final · Paso B · Compilar

Compilar Final.cs → el brazo robótico animado

Último comando de compilación. Al ejecutar Final.exe, Inventor arma la escena completa: base gris oscuro, brazo azul, antebrazo amarillo, pinza negra, caja verde y plataforma. La pinza agarra la caja, la traslada, la baja, se abre y se retira. Es el más visual de los cuatro ejemplos — y el que ves en la parte principal del tutorial.

Final · Paso B · Compilar

Compilar Final.cs → el brazo robótico animado

Último comando de compilación. Al ejecutar Final.exe. Resultado final del brazo robótico generado por Final.cs — versión pulida con Codex. Los colores coinciden con los pedidos en el prompt: base gris oscuro, brazo azul, antebrazo amarillo, pinza negra y caja verde. Es el más visual de los cuatro ejemplos; Codex también agregó una plataforma que hace más fácil entender la escena. (Detalle honesto: las pinzas de este resultado no están unidas físicamente al eje de la muñeca — se ven pegadas visualmente pero no lo están como constraint. Es el tipo de límite que aún aparece con prompts.)

1. Qué vas a hacer y qué necesitas

Vas a pedirle a una IA que te entregue un archivo .cs que, al compilarse, le dicta a Autodesk Inventor una pieza o una animación completa. En el caso principal: un brazo robótico de dos eslabones con pinza que agarra una caja verde, la traslada, la suelta y se retira.

Lo que debes tener listo

• Fase 1 funcionando en tu máquina. Este tutorial asume que ya lograste compilar y ejecutar el Fase1.exe del TUTORIAL ANTERIOR. Si csc.exe todavía no te compila nada, vuelve allí primero.
• La carpeta demoinv (C:\Users\TU_USUARIO\Documents\demoinv) con Autodesk.Inventor.Interop.dll ya adentro.
• Acceso a una IA con ventana de chat. En este tutorial usé dos: Claude (las 3 iteraciones intermedias: Fase 2, Fase 3 y Fase 4) y OpenAI Codex (la versión final pulida, Final.cs, que es la que ves en el tutorial principal). Cualquiera de las dos sirve; el prompt es prácticamente el mismo.
• El archivo HolaMundo.cs de Fase 1 a mano, opcional pero útil: sirve como ejemplo para que la IA entienda el estilo de código que esperas.

2. El flujo con IA en una imagen

En Fase 1 el recorrido era tu código → compilar → Inventor. En Fase 2 agregamos un eslabón al inicio: tu prompt → IA → código → compilar → Inventor.

Tener listo el archivo base

La IA entiende mejor qué le estás pidiendo si le das un ejemplo concreto del tipo de código que esperas. Por eso empezamos con HolaMundo.cs de Fase 1 abierto: lo subimos como referencia para que la IA vea el estilo, los using, cómo se conecta a Inventor, cómo dibuja. Sin ese contexto la IA puede entregarte código correcto pero con un estilo diferente, que quizá no compile con tu configuración.

Abrir la IA y pegar el prompt

Abre Claude o Codex. Adjunta HolaMundo.cs como referencia. Luego pega el prompt completo, que es el mismo en ambas herramientas.

El prompt que usé para el brazo robótico está completo en la sección 8 — puedes copiarlo tal cual. Lo importante por ahora es notar tres cosas de su estructura, porque es lo que hace que el código salga bien:

• Objetivo claro en una frase: “Crear un brazo robótico simple de dos eslabones...”. La IA necesita saber qué vas a construir antes que nada.
• Especificación visual y funcional: colores de cada parte (base gris oscuro, brazo azul, etc.) y secuencia de movimientos. Ese nivel de detalle evita que la IA invente.
• Restricciones técnicas al final: “Debe compilar con csc.exe usando Autodesk.Inventor.Interop.dll. El resultado debe ser exactamente un archivo llamado Final.cs.” Esta última parte obliga a la IA a entregar un archivo único, ejecutable, sin dependencias raras.

Guardar Final.cs en tu carpeta demoinv

La IA te devuelve el código en la ventana de chat. Tienes dos caminos para guardarlo, dependiendo de la herramienta:

Con Claude

Claude te muestra un botón Copy code arriba a la derecha del bloque. Haz clic, abre el Bloc de notas (o VS Code), pega con Ctrl+V, y guarda como Final.cs dentro de C:\Users\TU_USUARIO\Documents\demoinv. En el cuadro Guardar como, asegúrate de que el tipo sea Todos los archivos y no Documento de texto, o Windows te agregará .txt al final.

Con Codex

Codex trabaja distinto: en lugar de solo chat, ejecuta el código en un entorno sandbox y te deja descargar el archivo ya generado con un botón. Das clic, te baja un .cs, lo copias a demoinv. Menos pasos, menos posibilidad de que se rompa el formato.

Compilar con csc.exe

Abre el CMD (Win + R → cmd → Enter), entra a tu carpeta y ejecuta la compilación. El comando es una sola línea larga:

Ejecutar y ver el resultado

Con Inventor abierto (o cerrado — el código lo abre si hace falta), ejecuta el .exe:

Inventor toma el foco y empieza a construir el ensamble frente a ti. Ves aparecer la base, los eslabones coloreados, la pinza cerrada sobre la caja verde. Luego se mueve la secuencia completa: traslada la caja, la baja, abre la pinza y se retira. Cuando termine, queda todo modelado en Inventor como un ensamble normal, que puedes orbitar, medir o modificar.

8. El prompt completo del brazo robótico

Este es el texto exacto que pegué en Claude. Puedes copiarlo y modificar los colores, los movimientos o la forma de la pieza para generar variaciones. La estructura en tres bloques (objetivo, especificación, restricciones) es lo que mantengo fijo.

Crear un brazo robotico simple de dos eslabones, una pinza de dos
mordazas y una caja verde. La simulacion debe verse limpia y entendible.

Debe usar colores industriales:
- base gris oscuro
- brazo superior azul
- segundo brazo amarillo
- muñeca gris clara
- pinza negra
- caja verde

La animacion debe ser corta y clara:
- iniciar con la caja ya agarrada
- trasladarla
- bajarla
- abrir la pinza
- retirarse

Debe compilar con `csc.exe` usando `Autodesk.Inventor.Interop.dll`.
El resultado debe ser exactamente un archivo llamado `Final.cs`.

9. Galería: las 3 iteraciones con Claude que llevaron a la versión final

Antes de pedirle a Codex la versión pulida, hice tres iteraciones con Claude en las que fui sumando complejidad paso a paso. Cada una se apoyó en la anterior: primero una base y un eslabón; luego el mismo ensamble pero con constraints que permitían rotar; finalmente seis piezas conectadas con una animación tipo Drive Constraint. Son ejemplos tiles para ver cómo se construye un ensamble capa por capa — que es la forma más natural de trabajar con Claude: cada mensaje suma sobre lo anterior.

Después pasé a Codex con el prompt más largo y le pedí directamente la versión final coloreada, con plataforma, con caja verde moviéndose. Ese resultado es el Final.cs del tutorial principal — no aparece aquí abajo porque ya lo viste arriba.

Claude Ejemplo 2 · Fase 2

Ensamble básico: base + eslabón

Dos piezas separadas (una base cilíndrica y un eslabón rectangular vertical) unidas en un ensamble .iam. La base queda grounded. Todavía no hay movimiento — este es el punto de partida.

Ver prompt propuesto (aproximación)

Crea un ensamble simple en Autodesk Inventor con dos piezas:
- Una base cilíndrica de 10 cm de diámetro y 2 cm de alto.
- Un eslabón rectangular delgado (2 x 1 x 10 cm) colocado sobre la base.

La base debe estar fija (grounded). El programa debe:
1) crear cada pieza como un archivo .ipt separado,
2) crear un archivo de ensamble .iam que las una,
3) guardar todo dentro de la carpeta RobotDemo de Documentos.

Debe compilar con csc.exe usando Autodesk.Inventor.Interop.dll.
El resultado debe ser exactamente un archivo llamado Fase2.cs.

Descargar Fase2.cs — Google Drive GitHub

Claude Ejemplo 3 · Fase 3

Eslabón con rotación sobre la base

Mismo ensamble de la Fase 2, pero ahora con constraints que permiten al eslabón rotar libremente alrededor del eje vertical de la base. En la captura se ve al eslabón pintado en azul: indica que sigue siendo móvil.

Ver prompt propuesto (aproximación)

Toma el código de Fase 2 (base cilíndrica + eslabón rectangular)
y agrégale constraints de ensamble para que el eslabón pueda
rotar libremente sobre la base:

- Un Mate entre el eje Z de la base y el eje Z del eslabón
  (permite rotación alrededor del eje vertical).
- Un Mate entre el plano XY de la base y el plano XY del eslabón
  (fija la altura y evita que el eslabón se despegue).

El eslabón debe quedar como componente móvil, no grounded.
Mismas reglas de compilación: archivo único Fase3.cs, csc.exe,
Autodesk.Inventor.Interop.dll.

Descargar Fase3.cs — Google Drive GitHub

Claude Ejemplo 4 · Fase 4

Brazo completo: 6 piezas + animación Drive

Cadena cinemática completa con seis componentes — Base, Hombro, Brazo, Antebrazo, Muñeca y Garra — enlazados con Mate constraints, más una animación tipo Drive Constraint. La geometría todavía es en tonos grises: todo el foco está en que el mecanismo se mueva.

Ver prompt propuesto (aproximación)

Amplia el ensamble a un brazo robótico completo con 6 piezas:
Base cilíndrica, Hombro, Brazo (eslabón largo), Antebrazo,
Muñeca y Garra.

Cada par de piezas contiguas debe tener dos Mate constraints:
uno entre sus ejes Z (permite giro) y otro entre planos XY
(fija la altura). Forman una cadena cinemática apilada.

Agrega un Drive Constraint en la articulación Base-Hombro
para animar el brazo. El programa debe mostrar en consola
el progreso de creación de cada pieza.

Archivo único Fase4.cs, compilable con csc.exe y
Autodesk.Inventor.Interop.dll.

Descargar Fase4.cs — Google Drive GitHub

10. Claude vs Codex: qué noté

Usé las dos herramientas en el mismo experimento con distintos objetivos. Claude me sirvió para construir por partes (las tres iteraciones de la galería). Codex me sirvió para rematar con una versión más pulida visualmente. Ninguna es mejor en todo; cada una brilla en algo distinto.

11. Cómo escribir prompts que sí compilan

Dos de cada tres prompts que vés en Internet entregan código que no compila con csc.exe directo. No es que la IA esté mal: es que el prompt no incluyó la restricción. Estos son los patrones que a mí me han dado el mejor ratio de éxito:

1. Pide un archivo único. Literalmente: “El resultado debe ser exactamente un archivo llamado X.cs”. Esto evita que te entreguen un proyecto completo con .csproj, Program.cs, .sln, carpetas de bin/obj, etc.
2. Nombra el compilador. “Debe compilar con csc.exe usando Autodesk.Inventor.Interop.dll”. Así la IA usa APIs disponibles en .NET Framework 4, no en .NET 8+ que csc.exe de Windows no soporta.
3. Incluye las restricciones estéticas en listas. “Colores industriales: base gris oscuro, brazo azul...”. Una lista corta y concreta de 5-7 elementos es mejor que un párrafo narrado.
4. Define la duración o cantidad. “La animación debe ser corta, 5-8 segundos”. Sin eso te puede salir una animación de 30 segundos o una de 0.5 segundos que no alcanzas a ver.
5. Adjunta un ejemplo existente. Si subes HolaMundo.cs de Fase 1, la IA copia tu estilo, tus using y la manera en que te conectas a Inventor. Reduce muchísimo los errores de compatibilidad.

12. Qué se logró y hacia dónde va esto

Hicimos algo que hace cinco años habría sonado a ciencia ficción: describir una pieza en español, recibir un archivo .cs, compilarlo con una herramienta de 2003, y ver a Inventor construir la geometría solo. Cuatro veces. Sin escribir código.

El límite todavía existe, y es importante verlo: los 4 ejemplos son piezas aisladas, y aún en la versión más pulida hay detalles que no resuelve sola — como las pinzas del brazo robótico, que se ven bien pero no están realmente unidas al eje de la muñeca. Es una figura en el aire que en la vida real no podría existir.

Me recuerda al mismo camino que recorrieron las imágenes con IA: las primeras versiones te dibujaban personas con seis dedos, manos deformes, texturas que gritaban “soy artificial”. Un par de años después esas mismas herramientas generan fotografías que cuesta distinguir de una cámara real. Con el código CAD estamos en la primera etapa: los resultados aún tienen “pinzas flotantes”, pero ya se aproximan bastante a prototipos funcionales. En seis meses o un año esto va a ser otro nivel.

El horizonte es claro: software asistido por prompts. Cuando alguien de tu equipo diga “necesitamos diseñar 40 abrazaderas similares pero con 8 diámetros diferentes”, ya no será inevitable dibujarlas una por una ni aprender iLogic desde cero. Será describirlas en español, dejar que la IA genere el código, compilar, ejecutar. Es un cambio de paradigma interesante, y creo que las plataformas CAD todavía no lo integran nativamente justamente porque el nivel de detalle no está donde necesitan — pero llegará.

El próximo experimento va por otro lado: quiero probar el mismo flujo en el diseño de placas electrónicas. Cambiar el CAD mecánico por el EDA a ver si responde igual de bien. Si te interesa, suscríbete abajo para que te llegue cuando esté listo.