⏱️ Lectura: 11 min
British developer Joel Auterson had what he himself describes as a “crashout” this week: not a dramatic explosion, but a silent implosion of motivation. The cause wasn’t a critical bug or a difficult client: it was the feeling that coding without generative AI, something he had done for years as an essential part of his craft, stopped having value for the rest of the industry.
📑 En este artículo
Auterson, founder of the indie studio Bearwaves and author of the essay “Fuck it, make it anyway”, published on September 11, 2026, isn’t an isolated case. His story sums up a tension that runs through much of today’s developer community: how to keep enjoying the craft when the pressure to adopt code assistants keeps growing.
TL;DR
- British developer Joel Auterson (indie studio Bearwaves) published the essay “Fuck it, make it anyway” on September 11, 2026
- Auterson describes a personal ‘crashout’ triggered by the rise of generative AI in programming and video games
- The trigger was a thread by designer Zach Gage about how game development increasingly resembles the music industry
- His friend Shad is developing Uncamera, an iOS camera app that uses the RAW sensor and LUT tables instead of post-production filters, without generative AI
- Auterson identifies three paths in the face of AI: use it to compete, stop creating, or keep doing things by hand
- Before the AI boom, Auterson had built an interactive git branch picker that he used daily and was proud of
- Auterson is coding his own game engine in C++ instead of using Unity, Godot, or Unreal, because he enjoys the process
Introduction
The discussion around coding without ai generation stopped being an abstract conference debate and became a daily decision for thousands of developers. Auterson sums up the dilemma in three concrete options: use code assistants to avoid being left behind, stop creating altogether, or keep doing things the way he enjoys, even if it’s slower.
This article reconstructs what led Auterson to write his essay, what it says about other developers going through the same thing, and why his friend Shad’s case, with the camera app Uncamera, works as a practical counterexample showing that coding without generative AI is still viable in 2026.
What happened
The immediate trigger was a thread by game designer Zach Gage, where he argued that game development is increasingly resembling the music industry: anyone can produce something with the right tools, and scarcity of skill stops being a barrier to entry. Auterson called the idea “devastating”, not because it was wrong, but because it made him feel that years of learning might not matter.
Before that thread, Auterson had already been noticing the change in small things. He had built an interactive git branch picker that he used every day at his job as a programmer in the video game industry, a tool he was proud of and that his colleagues praised. Today, by his own account, anyone can ask an AI assistant to generate an equivalent tool with a single prompt.
Context and background
Auterson isn’t a conventional programmer. Besides running Bearwaves, his indie video game studio, he’s a published poet, a member of the Rare Mammals collective, and an alumnus of the Southbank New Poets and Barbican Young Poets programs in the UK. That creative double life explains why his crisis wasn’t only professional: it touched the way he understands the act of making things, whether code or poetry.
His most ambitious current project is his own game engine written in C++, technically the slowest option when ready-made alternatives like Unity, Godot, or Unreal Engine exist. Auterson is explicit about why he chooses the long path: he isn’t trying to compete on time-to-market, he’s trying to learn and enjoy the process of building a pseudo-3D renderer from first principles.
💭 Key takeaway: Uncamera and Auterson’s C++ engine share the same design decision: choosing the path that demands more manual work because the result, and the learning, are worth the cost.
Technical details and performance
The clearest example of coding without generative AI in practice doesn’t come from Auterson, but from his friend Shad, the designer and engineer behind Uncamera, an iOS camera app. Instead of applying a filter to the photo after it’s taken, as the vast majority of “vintage”-style camera apps do, Uncamera takes the sensor’s RAW output and processes it against a look-up table (LUT) calibrated to mimic how a specific film stock would respond.
The technical difference matters because it changes the point in the pipeline where the color transformation happens. A post-processing filter operates on an image already “developed” by the camera’s own processing, so it inherits whatever white balance or dynamic range compression decisions the manufacturer already made for you. Working directly on the RAW data gives Uncamera control over that decision starting from the first pixel.
| Approach | When to use it | Advantage | Limitation |
|---|---|---|---|
| Post-processing filter | Quick-editing apps like Instagram or VSCO | Easy to implement, applies to any photo already taken | The result depends on how well the camera already processed the original scene |
| LUT applied to the RAW sensor (Uncamera’s approach) | Apps aiming to mimic the optical and chemical behavior of a specific film stock | Color and grain are born at capture, not pasted on top | Requires RAW access and calibration work for each film “recipe” |
In code, applying a three-dimensional LUT to a pixel is, in essence, looking up a value in a table instead of calculating it with a formula:
def aplicar_lut_3d(pixel_rgb, lut):
r, g, b = pixel_rgb
indice = (int(r * (lut.tamano - 1)),
int(g * (lut.tamano - 1)),
int(b * (lut.tamano - 1)))
return lut.tabla[indice]
This snippet isn’t Uncamera’s actual code, which Shad hasn’t published, but it illustrates the idea: every red, green, and blue combination from the sensor maps to a precalculated entry in the table, the same logic that film and professional color grading LUTs have used for decades.
How to get started or try it
Coding without generative AI doesn’t mean rejecting every tool: it means choosing carefully which ones to use. Auterson’s own example, his git branch picker, is a good starting point for putting the idea into practice: building a small, useful doodad that’s entirely your own.
The branch picker uses fzf, a command-line fuzzy finder written in Go. Installing it takes one command, regardless of your operating system:
# Windows (with winget)
winget install junegunn.fzf
# Windows (with scoop)
scoop install fzf
# macOS (with Homebrew)
brew install fzf
# Linux (Debian/Ubuntu)
sudo apt install fzf
# Linux (Fedora)
sudo dnf install fzf
With fzf installed, the simplest picker is a single line:
# interactive branch picker with fzf
git switch $(git branch --format='%(refname:short)' | fzf)
This command passes the list of local branches to fzf, which opens an interactive finder, and uses the chosen branch as the argument to git switch. For a more complete version that includes remote branches, you can save it as a function:
gbr() {
local branch
branch=$(git branch --all --format='%(refname:short)' | \
grep -v '^origin/HEAD' | sort -u | \
fzf --height 40% --reverse --prompt="branch> ")
[ -n "$branch" ] && git switch "${branch#origin/}"
}
Save the gbr function in your .bashrc or .zshrc, open a new terminal, and type gbr inside any git repository. To confirm it loaded correctly, run type gbr: if it returns the function definition instead of a “command not found” error, it’s ready. After switching branches, git branch --show-current confirms the switch worked.
💡 Tip: This same exercise (taking a repetitive task from your workflow and solving it with a small tool you built yourself) is exactly the kind of “doodad” that Auterson says he stopped feeling was his own.
Impact and analysis
flowchart TD
A["Developer facing the AI boom"] --> B["Use generative AI to avoid falling behind"]
A --> C["Stop creating altogether"]
A --> D["Keep doing things by hand, for enjoyment and learning"]
B --> E["Loses enjoyment of the craft"]
C --> F["Not a real option for someone creative"]
D --> G["Keeps the learning and pride in the work"]
Auterson’s case doesn’t happen in a vacuum. More and more developers describe a similar tension: code assistants are genuinely capable, peer pressure to adopt them is real, and denying that capability, according to Auterson himself, “is running a race against a moving goalpost.” At the same time, for those who treat programming as a creative craft and not just a tool to reach a result, the loss of authorship over one’s own code has a cost that doesn’t show up in any speed benchmark.
Auterson sums up the three ways out he identifies for any developer facing this dilemma, ruling out two right away: using generative AI to “compete” takes away the enjoyment of the work; stopping creating isn’t a real option for someone creative. That leaves a third path: keep doing things the way he learned, despite the pressure.
What’s next
Shad continues developing Uncamera with the stated goal of competing for an Apple Design Award once the app is finished, built entirely without AI-generated code. Auterson, for his part, continues working on his C++ engine for Bearwaves and plans to keep sharing small tools, even if no one asks for them via prompt anymore.
The question the case leaves open is whether coding without generative AI can hold up as a viable minority choice in the long run, or whether it will end up being a niche curiosity, as already happens in other creative disciplines where handmade work became a distinguishing mark in itself.
Try it yourself: install fzf with brew install fzf (macOS) or sudo apt install fzf (Linux) and build your own git branch picker in an afternoon, without asking an AI assistant for a single line.
📖 Summary on Telegram: View summary
Frequently Asked Questions
Who is Joel Auterson?
He’s a British software developer who runs Bearwaves, his own indie video game studio, and also works in the video game industry as a programmer. He’s also a published poet, a member of the Rare Mammals collective, and an alumnus of the Southbank New Poets and Barbican Young Poets programs.
What is Uncamera?
It’s an iOS camera app developed by a friend of Auterson’s known as Shad. Instead of applying a filter to a photo after it’s taken, it processes the sensor’s RAW output against look-up tables (LUTs) calibrated to mimic the behavior of specific film stocks, without using generative AI in its development.
Why did Zach Gage’s thread affect Auterson so much?
Because it argued that game development is increasingly resembling the music industry, where modern tools lower the barrier to entry so much that technical skill accumulated over years stops being a differentiating advantage.
What is the interactive git branch picker mentioned in the article?
It’s a command-line tool that Auterson built to visually choose between branches in a git repository, instead of typing the full name of each one. He used it daily and his colleagues praised it, until he noticed that anyone could ask an AI assistant for an equivalent tool.
Does Auterson say no one should use AI to code?
No. His stance is personal: he acknowledges that denying the capability of code assistants is, in his words, “running a race against a moving goalpost”, but he explains that for him, coding with an AI assistant isn’t enjoyable and the result doesn’t feel like his own.
What is a LUT (look-up table) in photography or video?
It’s a precalculated table that maps every input color combination to a specific output color, instead of calculating the transformation with a formula in real time. It’s been used for decades in film and color grading, and it’s the technique behind Uncamera’s look.
References
- Fuck it, make it anyway, by Joel Auterson: the original essay that motivated this article, published on September 11, 2026.
- fzf on GitHub: official repository of the command-line fuzzy finder used in this article’s examples.
- Lookup table, Wikipedia: general explanation of the look-up table concept applied in the technical section.
- Indie game, Wikipedia: context on independent video game development, the field where both Auterson and Shad work.
📱 Enjoying this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day.
Imagen destacada: Foto de Jakub Żerdzicki en Unsplash
0 Comments