I Sent One AI Programmer Through 50 Years of Coding (Higgsfield AI Influencer)

0:00 This is one programmer in six [music] decades. [music] None of it was filmed. The strange part is how much the room changes. The

0:14 computer starts out bigger than the person and ends up in his spare room. So, I wanted to send one programmer through those different worlds without changing who he is every time the decade

0:24 changes. Meet Dev. One character, one standing take, six imagined workplaces. At the end, we'll put all six on the same clock. This video is sponsored by Higsfield. The experiment uses its AI

0:37 influencer studio to build dev, give him a performance, then change his clothes and surroundings. Here's a Higsfield example of a reference performance becoming a different character. For

0:47 ours, the interesting test is much quieter. Can a plain standing performance still feel like the same programmer after changing the world around him? First, the character. I kept

0:56 Dev fairly ordinary. Short chestnut hair, a slim build, casual clothes, glasses, and a mustache. Casual gives us a starting point. The decade clothes come later, so there's no need to make

1:07 the original character look like all six eras. The character button shows 1.12 credits. Once generated, dev is saved, ready to reuse for the video. There's already a small inconsistency here. The

1:20 portrait misses the glasses while the full body has them. check the actual images before moving on. Now he needs something to do. I don't own a camera, so even the performance is generated on

1:30 Higsfield. In the motion step, I select that standing clip from my generations, then select Dev as the character who will perform it. This transfer is set to 1080p, and the button shows 110 credits.

1:43 Here's the resulting base take. He makes a small turn and folds his arms. That's enough movement to compare and simple enough that the background won't hide the experiment. The reference and dev

1:53 are different inputs. One supplies the performance, the other the identity. Now that base video becomes the input for our changes. Our first stop is the 1970s, the computer room. Shirt tie and

2:05 a machine that makes this programmer look quite small. One university recollection describes a 1974 to75 class where programs went on to punch cards and results came back as printouts.

2:17 That's the idea behind this room. These scenes are our imagined versions of the decades rather than how every programmer actually lived. The first reference is just the outfit. In objects, the base

2:27 take goes in, then the clothes reference. The room stays for the next pass. This is a 720p swap with 77 credits on the button. You can see the generated outfit before changing the

2:39 surroundings. Then that outfit result becomes the next input. I give it the room reference and generate the setting also at the recorded 77 credits. Now compare it with the base. The glasses

2:50 and mustache still read as dev, while the tie and machinery do most of the storytelling. In the 1980s, our version of the computer has come home. Dev gets a sweater, and the workplace becomes a

3:01 bedroom desk. Basic was widely used on early microcomputers in the 70s and 80s. Our bedroom scene leans into that feeling of learning by trying things yourself. Here are the two inputs, the

3:12 sweater first, then the bedroom. Keeping those separate lets us judge the clothing change before adding another variable. The recording shows the same sequence again. Base take outfit

3:22 reference generate. The sweater result is then selected for the room pass. That second pass adds the desk and home computer. Both of these recorded buttons also show 77 credits at 720p. It's a

3:35 completely different mood from the computer room. Same recognizable face, smaller machine, and a workspace that feels much more personal. For the remaining four decades, I use those same

3:44 two steps. Their clicks aren't recorded, but the actual outputs are here in the generation history. Next, the 1990s cubicle, check shirt, khakis, a beige tower, and a large monitor. Our

3:56 programmer is now surrounded by an office. In 1993, the web software was released into the public domain. The desk could become a place to build for people beyond that office. The clothes

4:06 and room references carry those cues. They don't need a recognizable computer brand to make the era readable. But watch the camera distance here. It pulls back more than the original. The overall

4:17 gesture survives, yet the shot isn't an exact copy. The 2000s move us into an open office, lower partitions, flatter screens, and a polo shirt instead of the checked one. The agile manifesto

4:28 appeared in 2001, emphasizing working software, and responding to change. Our office is an illustration, not evidence, of how every team worked. The references asked for a lanyard as well, but it

4:40 doesn't survive in this final room result. That's another detail worth checking instead of assuming. More noticeably, he folds his arms earlier. Put the base beside it, and the timing

4:50 difference becomes obvious, even though Dev himself is still recognizable. The 2010s are our startup loft. Brick walls, shared desks, a hoodie, and a beanie. The clothes get relaxed while the work

5:00 stays connected. An early development and operations conference took place in 2009. That collaboration is the idea behind this decade's shared workspace. Again, the outfit reference and the

5:11 location reference have separate jobs. The room can change the atmosphere without us having to redesign Dev's face. In this result, the hoodie and brick background make the change easy to

5:21 read. Compare the full-frame too, not just whether the face looks convincing. Then the 2020s bring the office back home. Two monitors at night, a spare room, and dev standing right where the

5:32 day began. In the US, people primarily working from home nearly tripled between 2019 and 2021. That figure covers all workers, not specifically programmers. The headphones in the reference don't

5:44 appear in the final result. The room still tells the story, but a requested accessory isn't guaranteed. This one feels closest to a workspace many of us would recognize. You could be fixing

5:54 something at midnight with the rest of the house asleep. Now, all six together. Each clip starts from zero and runs on the same elapse clock. No slowing one down to make the gestures match. Look

6:05 closer at the 70s and 80s. Dev remains recognizable, but the machine and the room change the whole relationship between him and the work. The '90s camera and the 2000's arm timing are the

6:15 useful warning. Shared playback time makes the differences visible. It doesn't make them disappear. So, what did this experiment actually use? The balance started at 12,884.73

6:26 credits. It ended at 11,427.61. 61. That's a drop of 1,457.12. We can identify the character button, the motion transfer, and four recorded swaps. Those add up to 419.12

6:43 credits. The rest isn't itemized by these recordings. Reference generation. The other eight swaps and any retries aren't fully logged, so I won't invent their individual costs. If you try this,

6:54 save the character and the base take. Change the outfit first, check it, then use that result for the environment. compare at the same elapse time and check accessories, camera distance, and

7:05 gesture timing. A good-looking frame can still hide a change in the performance. For me, this works as a way to explore a character across different worlds. It gave us 12 variations from one base take

7:16 with visible limits to check. The fun part is how the workspace changes while you can still recognize the person. The link is below if you want to try your own version. Which decade would you have

7:26 survived?