{"id":1605,"date":"2025-11-08T21:34:47","date_gmt":"2025-11-08T20:34:47","guid":{"rendered":"https:\/\/stuff.tamius.net\/sacred-texts\/?p=1605"},"modified":"2025-11-08T21:36:47","modified_gmt":"2025-11-08T20:36:47","slug":"i-went-on-a-vibe-coding-adventure-heres-what-i-picked-up","status":"publish","type":"post","link":"https:\/\/stuff.tamius.net\/sacred-texts\/2025\/11\/08\/i-went-on-a-vibe-coding-adventure-heres-what-i-picked-up\/","title":{"rendered":"I went on a Vibe-Coding Adventure"},"content":{"rendered":"\n
Recently, I was lifting 3D models from video games again. Because the models I’m interested in character models with their poses preserved as on screen, the extracted models came out squished (because that’s how computer graphics and Intel GPA suite work). Unsquishing the models isn’t particularly complex, but the result often isn’t too exact. I wondered if I could automate that, and the answer was something along the lines of:<\/p>\n\n\n\n
\n
no, because I know very little about linear algebra and computer graphics<\/li>\n\n\n\n
but <\/em>I have some high-level knowledge and vague ideas of what the program would need to do in order to achieve the goal<\/li>\n<\/ul>\n\n\n\n
So I consulted with that famous XKCD automation chart: <\/p>\n\n\n\nhttps:\/\/xkcd.com\/1205\/<\/figcaption><\/figure>\n\n\n\n
… and it told me that automation is only saving me time if I spend somewhere between one day and one hour working on it. This is a problem, because if I wanted to do this task the old fashioned route, I’d need a lot more <\/em>than that. So I decided instead to go for the Billy Mitchell method, and opt for cheating with ChatGPT.<\/p>\n\n\n\n
The Concept<\/h2>\n\n\n\n
When extracting 3D models from games with Intel GPA, you get access to:<\/p>\n\n\n\n
\n
input geometry <\/strong>\u2014 that is, the 3D model the game is using as authored<\/em><\/li>\n\n\n\n
output geometry \u2014 <\/strong>that is, the 3D model your GPU is drawing, with all animations and transformations applied to it<\/li>\n<\/ul>\n\n\n\nInput (left) and output (right) geometry. Right is how you see the box when playing the game, left is how your graphics card sees the same box.<\/figcaption><\/figure>\n\n\n\n
Because all objects in a given capture are (presumably) squished by the same amounts, that means I could look at the scene, pick a landmark \u2014 an object without animations and that doesn’t appear stretched while playing the game \u2014 and export it in both input geometry <\/em>and output geometry <\/em>variants.<\/p>\n\n\n\n
The high-level algorithm is thus:<\/p>\n\n\n\n
\n
read .obj<\/code> file and parse it<\/li>\n\n\n\n
rotate input geometry <\/em>until it matches the rotation of output geometry<\/em><\/li>\n\n\n\n
compare bounding boxes of input <\/em>and output geometry<\/em> and determine the correct scaling factor along each axis<\/li>\n\n\n\n
normalize scaling factors so one of the scaling factors (preferably Y) equals to 1<\/code>.<\/li>\n<\/ul>\n\n\n\n
If you picked the correct object and if the code works properly, scaling factor for X axis should be equal to your in-game resolution’s aspect ratio.<\/p>\n\n\n\n
ChatGPT had very little issues up to this point, but as anyone who did any amount of programming probably knows: scope is an insidious beast that creeps and likes to prepare you ambushes. And wouldn’t you know: even saying it waited behind the corner would be a bit of an understatement.<\/p>\n\n\n\n
The First Round of Improvements<\/h2>\n\n\n\n
The obvious question is: if we can calculate how much we need to stretch our character … then why don’t we take our landmark’s input geometry, export both our landmark and<\/em> our character as our output geometry, and automatically scale our character?<\/p>\n\n\n\n
That doesn’t sound too hard, but then you remember that you probably don’t want your landmark in your 3D model. You only want your character, so you have to find a way to remove the landmark from your character. We also need to know which parts of our output geometry <\/em>are landmarks and which one aren’t, because our character needs to be ignored by the code that calculates the scaling factors.<\/p>\n\n\n\n
This is problematic, because geometry exported from Intel GPA doesn’t consist of meshes \u2014 you get a bunch of loose triangles that don’t actually share any vertices. Which means that if you want to identify and remove the landmark, you first have to connect those loose triangles into connected meshes. This can be achieved by deduplicating vertices: if there are two vertices in the same spot, merging them into one will also connect loose triangles into contiguous meshes.<\/p>\n\n\n\n
In short, our plan is:<\/p>\n\n\n\n
\n
deduplicate vertices, converting pile of loose triangles into contiguous meshes<\/li>\n\n\n\n
split said meshes into distinct objects<\/li>\n\n\n\n
find our landmark in output geometry,<\/li>\n\n\n\n
calculate correction factors and apply them<\/li>\n\n\n\n
export objects back into an .obj<\/code> file <\/li>\n<\/ul>\n\n\n\n
So what’s the problem?<\/p>\n\n\n\n
Well, there are several. In .obj<\/code>, 3D models are defined by two lists: list of all vertices and list of all faces. In those two lists, vertex is a line with three positions in space. Face is a line of text that basically says “this triangle connects first, second, and third vertex”. When you split meshes into distinct objects, you’re basically splitting this one giant list into lots of smaller lists. This means that numbers of each vertex change, and you need to account for that.<\/p>\n\n\n\n
The second problem is that when working with .obj<\/code> files, first vertex is “vertex 1”. However, in most programming languages, the first element in a list is “element 0.” <\/p>\n\n\n\n
The third problem is the second problem in reverse: when you’re exporting geometry back to .obj<\/code>, you need to re-number the vertices again \u2014 especially <\/em>if you removed your landmark object.<\/p>\n\n\n\n
ChatGPT was very well aware of this. I know because it explained it to me before writing its functions. But did ChatGPT account for that when it wrote its code?<\/p>\n\n\n\nQuick illustration of what I’m talking about.<\/figcaption><\/figure>\n\n\n\n
It took quite some prompting to get ChatGPT to fix the issue, but eventually it did… it just had to be constantly reminded about the distinction between 0-based and 1-based things.<\/p>\n\n\n\n
Second round of improvements<\/h2>\n\n\n\n
When it comes to 3D models, triangles have a front side and a back side. It is rather important that triangles face in the correct direction. Which way is considered correct depends and varies from game to game, from program to program, from game engine to game engine, and from graphics framework to graphics framework. When extracting 3D models from video games with Intel GPA suite, you can therefore end with situations where triangles of the models you extracted from the game will face in the wrong direction.<\/p>\n\n\n\n
I wanted to detect that. The idea was:<\/p>\n\n\n\n
\n
draw model onto a canvas<\/li>\n\n\n\n
color triangles facing towards the camera with orange, and triangles facing away from the camera with red<\/li>\n\n\n\n
read image data from the canvas<\/li>\n\n\n\n
if the canvas has more red than orange, then I know that triangles need to be flipped<\/li>\n<\/ul>\n\n\n\n
The prompt was pretty much this. ChatGPT came up with code that rendered something … however, rendered models were not rendered correctly, no matter how much I prodded in the prompts: they were always a mix of orange and red, even when I knew they should be either completely red or completely orange. Eventually, the “render preview” problem was solved by telling ChatGPT to draw the model twice \u2014 once in original orientation, with orange; and once with all triangles flipped, in red.<\/p>\n\n\n\n
For determining whether objects’ normals are flipped or not I decided to abandon the “figure it out by looking at the image approach” and told chatGPT to find a different way to do it, and it did. <\/p>\n\n\n\n
While ultimately chatGPT managed to give something that worked, one thing was becoming very apparent: if you try vibe-coding with zero knowledge about the thing you want to code, ChatGPT won’t save you. You still need to know what you’re doing.<\/p>\n\n\n\n
Third round of improvements<\/h2>\n\n\n\n
The other day, I used the program in order to fix a model I extracted from a game.<\/p>\n\n\n\n
3D models for 3D printing must not contain any holes in the mesh, which means that you have to ensure your model is manifold, watertight, and contains no sheets. If there are any holes (edge loops<\/em>, actually), you need to fill them. And after a very boring evening of filling those gaps manually, I asked myself: surely I could prompt ChatGPT into writing me a function or something that does that for me in less time than it took me to fill those holes.<\/em><\/p>\n\n\n\n
I also wanted it to sort the meshes that make up in object into several categories based on whether any edge-loops were auto-filled, whether auto-fill failed, whether final object is manifold, and whether final object contains any self-intersecting triangles.<\/p>\n\n\n\n
That was … a bit of a challenge. Initially, algorithm written by ChatGPT would either fail to fill edge loops, or it would corrupt the model entirely, to the point I had to revert the changes and start over. On the second attempt, ChatGPT did fill the holes without fucking up the export \u2014 but the normals of the newly added faces were oriented incorrectly. How did ChatGPT try to fix that? By adding shit ton of complex functions (though admittedly, I did tell it to not use any external libraries). It explained that it determined correct triangle orientation based on whether triangle was angled towards or away from the object’s center, or something like that.<\/p>\n\n\n\n
Correct answer for getting face orientation on the newly added faces right is to copy vertex winding from the neighbouring triangle \u2014 that is, if neightbouring triangle’s vertices are defined in clockwise order, you also need to list vertices of your newly added triangle in clockwise order. If you don’t, the new triangle will face the wrong way. And I had to point that out.<\/p>\n\n\n\n
The point about “you need to have at least moderate technical understanding of your problem if you want ChatGPT to give you a solution” is making its appearance once again.<\/p>\n\n\n\n
But that’s where ChatGPT success finally ends. Last task I had for it was: check if object has any self-intersections. ChatGPT provided M\u00f6ller’s test (or so it said) \u2014 but there was a bit of a problem: it was detecting intersections where there weren’t any, and no amount of prompting would make it fix its code. Which meant that I needed to implement that triangle check the good ol’ fashion way: go to stackoverflow, find someone who encountered the same problem as you, and borrow their solution. <\/p>\n\n\n\n
But with that, I think my little model fixing tool has all the features I want. So what’s some takeaways from this experience?<\/p>\n\n\n\n
The pros<\/h2>\n\n\n\n
You don’t have to learn about your problem \/ you don’t have to have low-level knowledge about your problem.<\/strong><\/p>\n\n\n\n
I must say \u2014 if I had to learn about computer graphics in order to write this problem, this experience wouldn’t be a few-days project for me. It would take at least a month or two.<\/p>\n\n\n\n
You can get the solution pretty quickly<\/strong><\/p>\n\n\n\n
See the previous point about “it would take a month or two.” <\/p>\n\n\n\n
You don’t have to think a lot<\/strong><\/p>\n\n\n\n
The cons<\/h2>\n\n\n\n
You don’t have to learn about your problem \/ you don’t have to have low-level knowledge about your problem.<\/strong><\/p>\n\n\n\n
When working on Ultrawidify, I feel like I was forced to learn at least a few of those things. With this project, I don’t feel like I learned anything. Because I didn’t learn a thing, I also didn’t really <\/em>understand the code ChatGPT spat at me. Which means that if there was a problem with the code, I kinda had to rely on ChatGPT finding me a fix, and fixing the code.<\/p>\n\n\n\n
And honestly \u2014 that kinda feels bad. I don’t ever feeling bad because I was lazy before.<\/p>\n\n\n\n
You don’t have to think a lot<\/strong><\/p>\n\n\n\n
Most of the time, at least. Just like physical exercise is good for your body, having to do the thinking is good for your brain. Thinking is a lot of “use it or lose it” kind of thing, and outsourcing your thinking to an AI is probably not too great of an idea.<\/em><\/p>\n\n\n\n
But you do need to give ChatGPT a relatively specific instructions, otherwise you’ll get garbage<\/strong><\/p>\n\n\n\n
This is why I don’t quite fear for my job security … yet.<\/p>\n\n\n\n
ChatGPT gives you spaghetti<\/strong><\/p>\n\n\n\n
I don’t feel that the code I got from ChatGPT is particularly maintainable. While spaghetti code is fine for small projects, in a real, large project that will need to be maintained for a long time? <\/p>\n\n\n\n
<\/p>\n\n\n\n
—<\/p>\n\n\n\n
But ultimately, I feel that despite all the cons, the chatGPT was still too <\/em>useful. When ChatGPT is good enough to outsource your thinking to, people are going to do that. And when people start to outsource their thinking to ChatGPT, that means they’ll think less \u2014 and, therefore, also learn and know less. Which is probably not the best direction. <\/p>\n\n\n\n
This isn’t to say “chatGPT bad”, because it’s pretty useful piece of tech (if you know how to use it) … just maybe don’t use it to do all your homework.<\/p>\n","protected":false},"excerpt":{"rendered":"
![\"is_it_worth_the_time_2x\"](\"https:\/\/stuff.tamius.net\/sacred-texts\/wp-content\/uploads\/2025\/11\/is_it_worth_the_time_2x-1024x832.png\")
![\"vc_0_input_output_geometry\"](\"https:\/\/stuff.tamius.net\/sacred-texts\/wp-content\/uploads\/2025\/11\/vc_0_input_output_geometry.webp\")
![\"vc_1_export-issues\"](\"https:\/\/stuff.tamius.net\/sacred-texts\/wp-content\/uploads\/2025\/11\/vc_1_export-issues-1024x732.webp\")