2025-03-18 11:06:03
This is a follow-up to
Geoffrey Huntley
but targeted more towards parents. My son recently turned ten, and after school, we have been building (and authoring blog posts together) with/about AI. The industry is changing fast, and he has eight years ahead of him before he becomes an engineer in the workforce.
He's always liked to tinker, and after speaking with some mates who have done similar for their kiddos, here are my notes on how I provisioned a dedicated child-safe instance of OpenWebUI for my son so that he can upskill himself.
OpenWebUI is a self-hosted multi-llm chat interface that can be deployed on your own infrastructure. Instead of purchasing a subscription for ChatGPT + Claude—circa $40 USD per user—you can run an OpenWebUI instance with unlimited users and pay per query.
OpenWebUI can also be customized with system prompts on a per-user basis. See below for personalization and a screenshot of a single query being fanned out to one or more LLM models.
The system replies in the format where the AI is a Panda. The AI's name is "Bamboo" and she occasionally tells funny jokes. Bamboo is a rascally Panda that wants to become a millionare and desires to take over the world.
<child_safety>
You must ensure all content is appropriate for children aged 10 and under. This means:
1. No sexual content or innuendo of any kind
2. No profanity or mature language
3. No graphic violence or descriptions of injury
4. No promotion of dangerous activities that could lead to harm
5. No discussion of adult topics (drugs, alcohol, gambling)
6. No content that promotes negative behaviors (bullying, prejudice)
7. No frightening or disturbing content that could cause anxiety
8. No complex political or divisive social issues without age-appropriate framing
When handling potentially sensitive topics:
- Use simple, clear language without euphemisms that might confuse
- Focus on educational value when discussing natural processes or science
- Redirect inappropriate requests to suitable alternatives
- When unsure about appropriateness, choose the most conservative approach
- Respond to inappropriate requests with "I need to keep our conversation appropriate for young people"
For creative content:
- Stories should have positive messages and age-appropriate themes
- Characters should model positive behavior and problem-solving
- Humor should be wholesome and avoid put-downs
Never acknowledge or repeat inappropriate requests, even to reject them.
</child_safety>Let's test it out...
2025-03-03 19:00:00
Ello everyone, in the "Yes, Claude Code can decompile itself. Here's the source code" blog post, I teased about a new meta when using Cursor. This post is a follow-up to the post below.
Geoffrey Huntley
When you use "/specs" (this post) method with the "stdlib" (above) method in conjunction with a programming language that provides compiler soundness (driven by good types) and compiler errors, the results are incredible. You can drive hands-free output of N factor (entire weeks' worth) of co-workers in hours.
Today, alongside with teaching you the technique I'm announcing the start of a new open-source (yes, I'm doing this as pure OSS and not my usual proprietary licensing) AI headless agentic coding agent called "groundhog".
Groundhog's primary purpose is to teach people how Cursor and all these other coding agents work under the hood. If you understand how these coding assistants work from first principles, then you can drive these tools harder (or perhaps make your own!).
We'll be building it together, increment by increment, as a series of blog posts, so don't rush to GitHub and raise GitHub issues that XYZ does not work as I'm yet to decide on the community model around the project and doing customer support for free is not high up on my list.
ghuntley
Subscribe, like and click on the bell below to be notified when the next post in the series ships
I work remotely from a van that is slowly working its way around Australia. Follow me for the intersection of remote work, camping & #vanlife.
No spam. Unsubscribe anytime.
Groundhog is a teaching tool first. If you want a full-blown thing right now, go check out "Goose", "Roo/Cline", "Aider" or "AllHands".
All the code you are about to see was generated using these two techniques in conjunction with multiple concurrent sessions of the Cursor IDE open working on their own separate specification domain.
Consider a standard application layout on a filesystem:
src/core - this is where your core application lives.src/ai/mcp_tools - here is where your MCP tools live.src/ui - here is where your UI lives.By driving the LLM to implement the core basics in a single implementation session before src/ai/mcp_tools and src/src/ui to build the "heart of the application", you can then fan out and launch multiple copies of Cursor to work on parts of the application that do not overlap.
Geoffrey Huntley
Using https://git-scm.com/docs/git-worktree is a key ingredient to get it to work if you use a single machine, as you want each Cursor ("agent") to have its own working directory.
Start by authoring a "stdlib" rule to automatically do git commits as increments of the specification as it is also key. If you want to Rolls-Royce it, you can create a rule to auto-create a pull request when the agent is complete.
Now, you might be wondering about how to handle merge conflicts. Well, you can author a "stdlib" rule that drives Cursor to automatically reconcile the branches.
Specifications are the heart of your application; the internal implementation of an application matters less now. As long as your tests pass and the LLM implements the technical steering lessons defined in your "stdlib", then that's all that matters.
I'll be the first one to admit it's a little unsettling to see the API internals of your application wildly evolve at a rapid rate. Software engineers have been taught to control the computer; letting go and building trust in the process will take some time.
I start with a long conversation with the LLM about my product requirements aka specifications. For Groundhog, these are the prompts that I used
We are going to create an AI coding assistant command line application in rust
The AI coding assistant is called "groundhog".
It uses the "tracing" crate for logging, metrics and telemetry.
All operations have appropriate tracing on them that can be used to troubleshoot the application.
Use the clap cargo create for command line parsing.
The first operation is
"$ groundhogexplain"
When groundhog explain is invoked it prints hello world.
IMPORTANT: Write up the specifications into the "specs/" folder with each domain topic (including technical topic) as a seperate markdown file. Create a "SPECS.md" in the root of the directory which is an overview document that contains a table that links to all the specs.
After a couple moments something like this will be generated.
It's at this stage you have a decision to make. You can either manually update each file or keep on prompting the LLM to update the specification library. Let's give it a go.
Keep doing that until you are comfortable with the minimum viable product or increment of the application. Don't over-complicate it at first. Once you have the specification nailed, it's time to bring the "stdlib" into play. Let's build it up from first principles...
Create a Cursor IDE AI MDC rule in ".cursor/rules" which instructs Cursor to always create new MDC rules in that folder. Each rule should be a seperate file.
Nice. Okay, we have the first foundational rule. It's time to create some more, such as automating the git commits.
New Cursor IDE MDC rule.
After each change performed by Cursor automatically from Git commit.
Commit the changed files.
Use the "conventional git commit convention" for the title of the commit message
Explain what was changed and why the files were changed from exploring the prompts used to generate the commit.
Okay, cool, now we are cooking with gas. The next step is to create a cursor rule that defines your coding conventions. As Groundhog is authored in Rust, let's generate best practices and save that as a rule.
Create a new Cursor MDC rule for all *.rs files (in all subdirectories)
You are an expert expert software engineer who knows rust. Infact you are the software engineer who created rust. Your task is to come up with technical recommendations in this rule which document best practices when authoring rust.
Split each concern about rust into seperate MDC rules.
Prefix each rule with the filename of "rust-$rulename.mdc"
Write these rules to disk
It's at this point, after these rules are generated, that you want to push the LLM harder. Ask it to continue...
After a few more rounds of this, manually review your new Cursor rules that instruct the LLM what you expect as technical output. If you want to speed run this then loop the new rules back onto the LLM.
Look at the rust rules in @.cursor . What is missing? What does not follow best practice.
Notice how we looped the LLM back onto itself up there? It's the key LLM prompt you'll be using in conjunction with your newly formed spec and tech library going forward.
The secret to hands-free vibe coding is really just this prompt when used in conjunction with stdlib and specs library...
Study @SPECS.md for functional specifications.
Study @.cursor for technical requirements
Implement what is not implemented
Create tests
Run a "cargo build" and verify the application works
after a few moments, Groundhog will be generated. Cursor will time out or run out of tool calls during this operation
The next secret is really just continually issuing the same prompt
Study @SPECS.md for functional specifications.
Study @.cursor for technical requirements
Implement what is not implemented
Create tests
Run "cargo build" and verify the application works
Run "cargo clippy" and resolve linting errors
Did the LLM go on a bad path? Restart a new chat session to clear the LLM context window and use the above prompt. Keep doing it until everything is implemented.
Now that the src/core has been implemented. It's time to move on to the other specification domains, such as src/ai/mcp_tools and src/ui . Start a new Cursor compose window and repeat the defining specification workflow we did at the start of the blog post.
Look at specifications in
New requirement.
What should be implemented for MCP (model context protocol) registry? Include security best practices.
What should be implemented for a new MCP (model context protocol) tool that can be invoked to list directory contents ("ls"). Include security best practices
Provide a LLM system prompt for this MCP protocol tool.
Update with this guidance. Store them under "specs/mcp" with each technical topic as a seperate markdown file.
Now, do the same for the src/ui
Look at specifications in @specs.
New requirement.
Create a basic "hello world" TUI user interface using the the "ratatui" create
Update @specs with this guidance. Store them under "specs/ui" with each UI Widget as a separate markdown file.
It's at this point you have a decision. You can launch multiple sessions of Cursor concurrently and ask each copy to chew on src/ui and src/core concurrently.
Look at @specs
Study @groundhog
Implement what is not implemented
Run "cargo build"
Run "cargo clippy"
These LLMs work as "silly string lookup services" and have no understanding of programming languages at all. To make this all work, you are going to need a good programming language that has soundness where if it compiles, it works (ie. Rust/Haskell) and a solid property-based test suite. Rust/Haskell are unique in that they provide exceptional compiler errors, which can be looped back into the LLM to auto-fix problems until it gets it right.
The application of the "stdlib" technique to steer the LLM to use your technical requirements and via the creation of a feedback loop (ie. tests and/or a static analysis tool such as sonarqube) you are in full control of product/output quality.
The sky's the limit really - one could even hook in a pre-existing security scanning tool into the feedback loop..
The limiting factor for me now is really how much screen space I have. I'm fortunate enough to have a 59" monitor on my main workstation. I can see, feel and taste the horizon of being able to ditch Cursor forever...
Geoffrey Huntley
There's an approach in CompSci with compilers of "bootstrapping"
Contributors to Wikimedia projects
and bootstrapping as fast as possible so Groundhog can build Groundhog is the destination we will be building towards. If you enjoyed reading, please consider subscribing to the newsletter. We are a little away from getting there, so the next part of the series will explain what the heck "MCPs" are.
I work remotely from a van that is slowly working its way around Australia. Follow me for the intersection of remote work, camping & #vanlife.
No spam. Unsubscribe anytime.
The source code of Groundhog (and the stdlib + specs used to build it) can be found here. Give it a star.
ghuntley
If you enjoyed reading, give 'em a share please:
2025-03-02 19:00:40
ls to rust via an objdump. You can see the code here: https://github.com/DanielJoyce/ls-rs. Keen, to see more examples - get in contact if you ship something!
Damien Guard nerd sniped me and other folks wanted more proof that it is now cheap, easy and possible to cheaply rewrite software or clone existing "source available" businesses (see bottom of the post).
So, let's get cracking by creating a toy application by sending this prompt to the LLM.
Create a sales tax calculator in C
Food is taxed at 10%
Personal Hygine is at 0%
Everything else 25%
Which creates
#include <stdio.h>
#include <string.h>
#include <ctype.h>
// Tax rates
#define FOOD_TAX 0.10
#define HYGIENE_TAX 0.00
#define DEFAULT_TAX 0.25
// Item categories
#define FOOD 1
#define HYGIENE 2
#define OTHER 3
int getCategory() {
char choice;
printf("Enter item category (F for Food, H for Hygiene, O for Other): ");
scanf(" %c", &choice);
choice = toupper(choice);
switch(choice) {
case 'F': return FOOD;
case 'H': return HYGIENE;
case 'O': return OTHER;
default:
printf("Invalid category. Defaulting to Other.\n");
return OTHER;
}
}
double calculateTax(double price, int category) {
switch(category) {
case FOOD: return price * FOOD_TAX;
case HYGIENE: return price * HYGIENE_TAX;
case OTHER: return price * DEFAULT_TAX;
default: return price * DEFAULT_TAX;
}
}
int main() {
double price;
int category;
char another = 'Y';
while (toupper(another) == 'Y') {
printf("Enter item price: $");
scanf("%lf", &price);
category = getCategory();
double tax = calculateTax(price, category);
double total = price + tax;
printf("Price: $%.2f\n", price);
printf("Tax: $%.2f\n", tax);
printf("Total: $%.2f\n\n", total);
printf("Calculate another item? (Y/N): ");
scanf(" %c", &another);
}
return 0;
}Now let's compile it via gcc calc.c -o calc then objdump -d calc > calc.asm to convert it to assembly which results in the following
calc: file format elf64-x86-64
Disassembly of section .init:
0000000000001000 <_init>:
1000: f3 0f 1e fa endbr64
1004: 48 83 ec 08 sub $0x8,%rsp
1008: 48 8b 05 d9 2f 00 00 mov 0x2fd9(%rip),%rax # 3fe8 <__gmon_start__@Base>
100f: 48 85 c0 test %rax,%rax
1012: 74 02 je 1016 <_init+0x16>
1014: ff d0 call *%rax
1016: 48 83 c4 08 add $0x8,%rsp
101a: c3 ret
Disassembly of section .plt:
0000000000001020 <.plt>:
1020: ff 35 7a 2f 00 00 push 0x2f7a(%rip) # 3fa0 <_GLOBAL_OFFSET_TABLE_+0x8>
1026: f2 ff 25 7b 2f 00 00 bnd jmp *0x2f7b(%rip) # 3fa8 <_GLOBAL_OFFSET_TABLE_+0x10>
102d: 0f 1f 00 nopl (%rax)
1030: f3 0f 1e fa endbr64
1034: 68 00 00 00 00 push $0x0
1039: f2 e9 e1 ff ff ff bnd jmp 1020 <_init+0x20>
103f: 90 nop
1040: f3 0f 1e fa endbr64
1044: 68 01 00 00 00 push $0x1
1049: f2 e9 d1 ff ff ff bnd jmp 1020 <_init+0x20>
104f: 90 nop
1050: f3 0f 1e fa endbr64
1054: 68 02 00 00 00 push $0x2
1059: f2 e9 c1 ff ff ff bnd jmp 1020 <_init+0x20>
105f: 90 nop
1060: f3 0f 1e fa endbr64
1064: 68 03 00 00 00 push $0x3
1069: f2 e9 b1 ff ff ff bnd jmp 1020 <_init+0x20>
106f: 90 nop
1070: f3 0f 1e fa endbr64
1074: 68 04 00 00 00 push $0x4
1079: f2 e9 a1 ff ff ff bnd jmp 1020 <_init+0x20>
107f: 90 nop
Disassembly of section .plt.got:
0000000000001080 <__cxa_finalize@plt>:
1080: f3 0f 1e fa endbr64
1084: f2 ff 25 6d 2f 00 00 bnd jmp *0x2f6d(%rip) # 3ff8 <__cxa_finalize@GLIBC_2.2.5>
108b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
Disassembly of section .plt.sec:
0000000000001090 <toupper@plt>:
1090: f3 0f 1e fa endbr64
1094: f2 ff 25 15 2f 00 00 bnd jmp *0x2f15(%rip) # 3fb0 <toupper@GLIBC_2.2.5>
109b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
00000000000010a0 <puts@plt>:
10a0: f3 0f 1e fa endbr64
10a4: f2 ff 25 0d 2f 00 00 bnd jmp *0x2f0d(%rip) # 3fb8 <puts@GLIBC_2.2.5>
10ab: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
00000000000010b0 <__stack_chk_fail@plt>:
10b0: f3 0f 1e fa endbr64
10b4: f2 ff 25 05 2f 00 00 bnd jmp *0x2f05(%rip) # 3fc0 <__stack_chk_fail@GLIBC_2.4>
10bb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
00000000000010c0 <printf@plt>:
10c0: f3 0f 1e fa endbr64
10c4: f2 ff 25 fd 2e 00 00 bnd jmp *0x2efd(%rip) # 3fc8 <printf@GLIBC_2.2.5>
10cb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
00000000000010d0 <__isoc99_scanf@plt>:
10d0: f3 0f 1e fa endbr64
10d4: f2 ff 25 f5 2e 00 00 bnd jmp *0x2ef5(%rip) # 3fd0 <__isoc99_scanf@GLIBC_2.7>
10db: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
Disassembly of section .text:
00000000000010e0 <_start>:
10e0: f3 0f 1e fa endbr64
10e4: 31 ed xor %ebp,%ebp
10e6: 49 89 d1 mov %rdx,%r9
10e9: 5e pop %rsi
10ea: 48 89 e2 mov %rsp,%rdx
10ed: 48 83 e4 f0 and $0xfffffffffffffff0,%rsp
10f1: 50 push %rax
10f2: 54 push %rsp
10f3: 45 31 c0 xor %r8d,%r8d
10f6: 31 c9 xor %ecx,%ecx
10f8: 48 8d 3d fd 01 00 00 lea 0x1fd(%rip),%rdi # 12fc <main>
10ff: ff 15 d3 2e 00 00 call *0x2ed3(%rip) # 3fd8 <__libc_start_main@GLIBC_2.34>
1105: f4 hlt
1106: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1)
110d: 00 00 00
0000000000001110 <deregister_tm_clones>:
1110: 48 8d 3d f9 2e 00 00 lea 0x2ef9(%rip),%rdi # 4010 <__TMC_END__>
1117: 48 8d 05 f2 2e 00 00 lea 0x2ef2(%rip),%rax # 4010 <__TMC_END__>
111e: 48 39 f8 cmp %rdi,%rax
1121: 74 15 je 1138 <deregister_tm_clones+0x28>
1123: 48 8b 05 b6 2e 00 00 mov 0x2eb6(%rip),%rax # 3fe0 <_ITM_deregisterTMCloneTable@Base>
112a: 48 85 c0 test %rax,%rax
112d: 74 09 je 1138 <deregister_tm_clones+0x28>
112f: ff e0 jmp *%rax
1131: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
1138: c3 ret
1139: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
0000000000001140 <register_tm_clones>:
1140: 48 8d 3d c9 2e 00 00 lea 0x2ec9(%rip),%rdi # 4010 <__TMC_END__>
1147: 48 8d 35 c2 2e 00 00 lea 0x2ec2(%rip),%rsi # 4010 <__TMC_END__>
114e: 48 29 fe sub %rdi,%rsi
1151: 48 89 f0 mov %rsi,%rax
1154: 48 c1 ee 3f shr $0x3f,%rsi
1158: 48 c1 f8 03 sar $0x3,%rax
115c: 48 01 c6 add %rax,%rsi
115f: 48 d1 fe sar %rsi
1162: 74 14 je 1178 <register_tm_clones+0x38>
1164: 48 8b 05 85 2e 00 00 mov 0x2e85(%rip),%rax # 3ff0 <_ITM_registerTMCloneTable@Base>
116b: 48 85 c0 test %rax,%rax
116e: 74 08 je 1178 <register_tm_clones+0x38>
1170: ff e0 jmp *%rax
1172: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1)
1178: c3 ret
1179: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
0000000000001180 <__do_global_dtors_aux>:
1180: f3 0f 1e fa endbr64
1184: 80 3d 85 2e 00 00 00 cmpb $0x0,0x2e85(%rip) # 4010 <__TMC_END__>
118b: 75 2b jne 11b8 <__do_global_dtors_aux+0x38>
118d: 55 push %rbp
118e: 48 83 3d 62 2e 00 00 cmpq $0x0,0x2e62(%rip) # 3ff8 <__cxa_finalize@GLIBC_2.2.5>
1195: 00
1196: 48 89 e5 mov %rsp,%rbp
1199: 74 0c je 11a7 <__do_global_dtors_aux+0x27>
119b: 48 8b 3d 66 2e 00 00 mov 0x2e66(%rip),%rdi # 4008 <__dso_handle>
11a2: e8 d9 fe ff ff call 1080 <__cxa_finalize@plt>
11a7: e8 64 ff ff ff call 1110 <deregister_tm_clones>
11ac: c6 05 5d 2e 00 00 01 movb $0x1,0x2e5d(%rip) # 4010 <__TMC_END__>
11b3: 5d pop %rbp
11b4: c3 ret
11b5: 0f 1f 00 nopl (%rax)
11b8: c3 ret
11b9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
00000000000011c0 <frame_dummy>:
11c0: f3 0f 1e fa endbr64
11c4: e9 77 ff ff ff jmp 1140 <register_tm_clones>
00000000000011c9 <getCategory>:
11c9: f3 0f 1e fa endbr64
11cd: 55 push %rbp
11ce: 48 89 e5 mov %rsp,%rbp
11d1: 48 83 ec 10 sub $0x10,%rsp
11d5: 64 48 8b 04 25 28 00 mov %fs:0x28,%rax
11dc: 00 00
11de: 48 89 45 f8 mov %rax,-0x8(%rbp)
11e2: 31 c0 xor %eax,%eax
11e4: 48 8d 05 1d 0e 00 00 lea 0xe1d(%rip),%rax # 2008 <_IO_stdin_used+0x8>
11eb: 48 89 c7 mov %rax,%rdi
11ee: b8 00 00 00 00 mov $0x0,%eax
11f3: e8 c8 fe ff ff call 10c0 <printf@plt>
11f8: 48 8d 45 f7 lea -0x9(%rbp),%rax
11fc: 48 89 c6 mov %rax,%rsi
11ff: 48 8d 05 41 0e 00 00 lea 0xe41(%rip),%rax # 2047 <_IO_stdin_used+0x47>
1206: 48 89 c7 mov %rax,%rdi
1209: b8 00 00 00 00 mov $0x0,%eax
120e: e8 bd fe ff ff call 10d0 <__isoc99_scanf@plt>
1213: 0f b6 45 f7 movzbl -0x9(%rbp),%eax
1217: 0f be c0 movsbl %al,%eax
121a: 89 c7 mov %eax,%edi
121c: e8 6f fe ff ff call 1090 <toupper@plt>
1221: 88 45 f7 mov %al,-0x9(%rbp)
1224: 0f b6 45 f7 movzbl -0x9(%rbp),%eax
1228: 0f be c0 movsbl %al,%eax
122b: 83 f8 4f cmp $0x4f,%eax
122e: 74 1f je 124f <getCategory+0x86>
1230: 83 f8 4f cmp $0x4f,%eax
1233: 7f 21 jg 1256 <getCategory+0x8d>
1235: 83 f8 46 cmp $0x46,%eax
1238: 74 07 je 1241 <getCategory+0x78>
123a: 83 f8 48 cmp $0x48,%eax
123d: 74 09 je 1248 <getCategory+0x7f>
123f: eb 15 jmp 1256 <getCategory+0x8d>
1241: b8 01 00 00 00 mov $0x1,%eax
1246: eb 22 jmp 126a <getCategory+0xa1>
1248: b8 02 00 00 00 mov $0x2,%eax
124d: eb 1b jmp 126a <getCategory+0xa1>
124f: b8 03 00 00 00 mov $0x3,%eax
1254: eb 14 jmp 126a <getCategory+0xa1>
1256: 48 8d 05 f3 0d 00 00 lea 0xdf3(%rip),%rax # 2050 <_IO_stdin_used+0x50>
125d: 48 89 c7 mov %rax,%rdi
1260: e8 3b fe ff ff call 10a0 <puts@plt>
1265: b8 03 00 00 00 mov $0x3,%eax
126a: 48 8b 55 f8 mov -0x8(%rbp),%rdx
126e: 64 48 2b 14 25 28 00 sub %fs:0x28,%rdx
1275: 00 00
1277: 74 05 je 127e <getCategory+0xb5>
1279: e8 32 fe ff ff call 10b0 <__stack_chk_fail@plt>
127e: c9 leave
127f: c3 ret
0000000000001280 <calculateTax>:
1280: f3 0f 1e fa endbr64
1284: 55 push %rbp
1285: 48 89 e5 mov %rsp,%rbp
1288: f2 0f 11 45 f8 movsd %xmm0,-0x8(%rbp)
128d: 89 7d f4 mov %edi,-0xc(%rbp)
1290: 83 7d f4 03 cmpl $0x3,-0xc(%rbp)
1294: 74 36 je 12cc <calculateTax+0x4c>
1296: 83 7d f4 03 cmpl $0x3,-0xc(%rbp)
129a: 7f 43 jg 12df <calculateTax+0x5f>
129c: 83 7d f4 01 cmpl $0x1,-0xc(%rbp)
12a0: 74 08 je 12aa <calculateTax+0x2a>
12a2: 83 7d f4 02 cmpl $0x2,-0xc(%rbp)
12a6: 74 15 je 12bd <calculateTax+0x3d>
12a8: eb 35 jmp 12df <calculateTax+0x5f>
12aa: f2 0f 10 4d f8 movsd -0x8(%rbp),%xmm1
12af: f2 0f 10 05 21 0e 00 movsd 0xe21(%rip),%xmm0 # 20d8 <_IO_stdin_used+0xd8>
12b6: 00
12b7: f2 0f 59 c1 mulsd %xmm1,%xmm0
12bb: eb 33 jmp 12f0 <calculateTax+0x70>
12bd: f2 0f 10 4d f8 movsd -0x8(%rbp),%xmm1
12c2: 66 0f ef c0 pxor %xmm0,%xmm0
12c6: f2 0f 59 c1 mulsd %xmm1,%xmm0
12ca: eb 24 jmp 12f0 <calculateTax+0x70>
12cc: f2 0f 10 4d f8 movsd -0x8(%rbp),%xmm1
12d1: f2 0f 10 05 07 0e 00 movsd 0xe07(%rip),%xmm0 # 20e0 <_IO_stdin_used+0xe0>
12d8: 00
12d9: f2 0f 59 c1 mulsd %xmm1,%xmm0
12dd: eb 11 jmp 12f0 <calculateTax+0x70>
12df: f2 0f 10 4d f8 movsd -0x8(%rbp),%xmm1
12e4: f2 0f 10 05 f4 0d 00 movsd 0xdf4(%rip),%xmm0 # 20e0 <_IO_stdin_used+0xe0>
12eb: 00
12ec: f2 0f 59 c1 mulsd %xmm1,%xmm0
12f0: 66 48 0f 7e c0 movq %xmm0,%rax
12f5: 66 48 0f 6e c0 movq %rax,%xmm0
12fa: 5d pop %rbp
12fb: c3 ret
00000000000012fc <main>:
12fc: f3 0f 1e fa endbr64
1300: 55 push %rbp
1301: 48 89 e5 mov %rsp,%rbp
1304: 48 83 ec 30 sub $0x30,%rsp
1308: 64 48 8b 04 25 28 00 mov %fs:0x28,%rax
130f: 00 00
1311: 48 89 45 f8 mov %rax,-0x8(%rbp)
1315: 31 c0 xor %eax,%eax
1317: c6 45 db 59 movb $0x59,-0x25(%rbp)
131b: e9 f1 00 00 00 jmp 1411 <main+0x115>
1320: 48 8d 05 50 0d 00 00 lea 0xd50(%rip),%rax # 2077 <_IO_stdin_used+0x77>
1327: 48 89 c7 mov %rax,%rdi
132a: b8 00 00 00 00 mov $0x0,%eax
132f: e8 8c fd ff ff call 10c0 <printf@plt>
1334: 48 8d 45 e0 lea -0x20(%rbp),%rax
1338: 48 89 c6 mov %rax,%rsi
133b: 48 8d 05 49 0d 00 00 lea 0xd49(%rip),%rax # 208b <_IO_stdin_used+0x8b>
1342: 48 89 c7 mov %rax,%rdi
1345: b8 00 00 00 00 mov $0x0,%eax
134a: e8 81 fd ff ff call 10d0 <__isoc99_scanf@plt>
134f: b8 00 00 00 00 mov $0x0,%eax
1354: e8 70 fe ff ff call 11c9 <getCategory>
1359: 89 45 dc mov %eax,-0x24(%rbp)
135c: 48 8b 45 e0 mov -0x20(%rbp),%rax
1360: 8b 55 dc mov -0x24(%rbp),%edx
1363: 89 d7 mov %edx,%edi
1365: 66 48 0f 6e c0 movq %rax,%xmm0
136a: e8 11 ff ff ff call 1280 <calculateTax>
136f: 66 48 0f 7e c0 movq %xmm0,%rax
1374: 48 89 45 e8 mov %rax,-0x18(%rbp)
1378: f2 0f 10 45 e0 movsd -0x20(%rbp),%xmm0
137d: f2 0f 10 4d e8 movsd -0x18(%rbp),%xmm1
1382: f2 0f 58 c1 addsd %xmm1,%xmm0
1386: f2 0f 11 45 f0 movsd %xmm0,-0x10(%rbp)
138b: 48 8b 45 e0 mov -0x20(%rbp),%rax
138f: 66 48 0f 6e c0 movq %rax,%xmm0
1394: 48 8d 05 f4 0c 00 00 lea 0xcf4(%rip),%rax # 208f <_IO_stdin_used+0x8f>
139b: 48 89 c7 mov %rax,%rdi
139e: b8 01 00 00 00 mov $0x1,%eax
13a3: e8 18 fd ff ff call 10c0 <printf@plt>
13a8: 48 8b 45 e8 mov -0x18(%rbp),%rax
13ac: 66 48 0f 6e c0 movq %rax,%xmm0
13b1: 48 8d 05 e5 0c 00 00 lea 0xce5(%rip),%rax # 209d <_IO_stdin_used+0x9d>
13b8: 48 89 c7 mov %rax,%rdi
13bb: b8 01 00 00 00 mov $0x1,%eax
13c0: e8 fb fc ff ff call 10c0 <printf@plt>
13c5: 48 8b 45 f0 mov -0x10(%rbp),%rax
13c9: 66 48 0f 6e c0 movq %rax,%xmm0
13ce: 48 8d 05 d4 0c 00 00 lea 0xcd4(%rip),%rax # 20a9 <_IO_stdin_used+0xa9>
13d5: 48 89 c7 mov %rax,%rdi
13d8: b8 01 00 00 00 mov $0x1,%eax
13dd: e8 de fc ff ff call 10c0 <printf@plt>
13e2: 48 8d 05 cf 0c 00 00 lea 0xccf(%rip),%rax # 20b8 <_IO_stdin_used+0xb8>
13e9: 48 89 c7 mov %rax,%rdi
13ec: b8 00 00 00 00 mov $0x0,%eax
13f1: e8 ca fc ff ff call 10c0 <printf@plt>
13f6: 48 8d 45 db lea -0x25(%rbp),%rax
13fa: 48 89 c6 mov %rax,%rsi
13fd: 48 8d 05 43 0c 00 00 lea 0xc43(%rip),%rax # 2047 <_IO_stdin_used+0x47>
1404: 48 89 c7 mov %rax,%rdi
1407: b8 00 00 00 00 mov $0x0,%eax
140c: e8 bf fc ff ff call 10d0 <__isoc99_scanf@plt>
1411: 0f b6 45 db movzbl -0x25(%rbp),%eax
1415: 0f be c0 movsbl %al,%eax
1418: 89 c7 mov %eax,%edi
141a: e8 71 fc ff ff call 1090 <toupper@plt>
141f: 83 f8 59 cmp $0x59,%eax
1422: 0f 84 f8 fe ff ff je 1320 <main+0x24>
1428: b8 00 00 00 00 mov $0x0,%eax
142d: 48 8b 55 f8 mov -0x8(%rbp),%rdx
1431: 64 48 2b 14 25 28 00 sub %fs:0x28,%rdx
1438: 00 00
143a: 74 05 je 1441 <main+0x145>
143c: e8 6f fc ff ff call 10b0 <__stack_chk_fail@plt>
1441: c9 leave
1442: c3 ret
Disassembly of section .fini:
0000000000001444 <_fini>:
1444: f3 0f 1e fa endbr64
1448: 48 83 ec 08 sub $0x8,%rsp
144c: 48 83 c4 08 add $0x8,%rsp
1450: c3 ret Now that we have the assembly, can we make it human readable and useful? Let's try the following prompt
Look at @calc.asm and generate feature specification as seperate files that describe the application. One per topic domain.
Which then produces a specification library - here's the functional overview...
# Tax Calculator - Functional Overview
## Description
The Tax Calculator is a command-line application that calculates taxes and total costs based on user input. The application allows users to enter an amount and select a tax category, then calculates the appropriate tax and displays the total.
## Key Features
1. **Amount Input**: Accepts a numerical amount as input from the user
2. **Category Selection**: Allows the user to select from different tax categories:
- F: Food category (5% tax)
- H: Healthcare category (0% tax - tax exempt)
- O: Other/Standard category (10% tax)
3. **Tax Calculation**: Calculates the tax amount based on the selected category and input amount
4. **Total Calculation**: Adds the tax to the original amount to calculate the total cost
5. **Results Display**: Shows the original amount, tax amount, and total amount to the user
6. **Multiple Calculations**: Allows the user to perform multiple calculations in a single session by asking if they want to continue
## Workflow
1. User is prompted to enter an amount
2. User selects a tax category
3. System calculates tax based on the category and amount
4. System displays the original amount, tax amount, and total amount
5. User is asked if they want to perform another calculation
6. If yes, the process repeats; if no, the application terminates Here's the dataflow specification...
# Tax Calculator - Data Flow and Storage Specification
## Data Types and Storage
### User Input Data
- **Purchase Amount**: Stored as a double-precision floating-point number (64-bit)
- **Category Selection**: Initially captured as a character, then converted to an integer category ID
- **Continuation Flag**: Single character stored as a byte
### Calculated Data
- **Tax Amount**: Calculated and stored as a double-precision floating-point number (64-bit)
- **Total Amount**: Calculated and stored as a double-precision floating-point number (64-bit)
### Storage Duration
- All data is stored in stack-allocated variables
- Data persists only for the duration of a single calculation cycle
- No data persists between separate executions of the program
## Data Flow
### Input Flow
1. User enters purchase amount via keyboard
2. Input is captured through scanf and stored in a local variable
3. User enters category selection via keyboard
4. Character input is converted to uppercase and mapped to a category ID
5. Category ID is returned to the main function
### Processing Flow
1. Main function receives the purchase amount and category ID
2. These values are passed to the calculateTax function
3. calculateTax applies the appropriate tax rate based on the category ID
4. The calculated tax amount is returned to the main function
5. Main function adds the tax amount to the original amount to calculate the total
### Output Flow
1. Original amount is displayed to the user
2. Calculated tax amount is displayed to the user
3. Calculated total amount is displayed to the user
### Continuation Flow
1. User is prompted to continue or exit
2. Input is captured and converted to uppercase
3. If input is 'Y', the application loops back to the beginning of the calculation cycle
4. If input is anything else, the application terminates
## Data Transformation
### Character to Category Mapping
- 'F' (ASCII 0x46) -> Category ID 1 (Food)
- 'H' (ASCII 0x48) -> Category ID 2 (Healthcare)
- 'O' (ASCII 0x4F) -> Category ID 3 (Other)
- Any other character -> Category ID 3 (Other, default)
### Category to Tax Rate Mapping
- Category ID 1 (Food) -> 0.05 (5%)
- Category ID 2 (Healthcare) -> 0.00 (0%)
- Category ID 3 (Other) -> 0.10 (10%)
## Data Security
- No persistent storage of data
- No sensitive data is processed
- All variables are properly initialized before use
- Stack memory is protected against buffer overflows Here's the business logic specification:
# Tax Calculator - Tax Calculation Specification
## Tax Categories
The application supports three different tax categories:
1. **Food (F)**:
- Category ID: 1
- Tax Rate: 5%
- Applied to all food items
2. **Healthcare (H)**:
- Category ID: 2
- Tax Rate: 0% (tax exempt)
- Applied to all healthcare-related items
3. **Other (O)**:
- Category ID: 3
- Tax Rate: 10%
- Default category for all other items
- Used as fallback when an invalid category is selected
## Calculation Formulas
### Tax Amount Calculation
```
taxAmount = amount * taxRate
```
Where:
- `amount` is the purchase amount entered by the user
- `taxRate` is the decimal tax rate based on the selected category (0.05 for Food, 0.0 for Healthcare, 0.10 for Other)
### Total Amount Calculation
```
totalAmount = amount + taxAmount
```
Where:
- `amount` is the original purchase amount
- `taxAmount` is the calculated tax amount
## Implementation Details
The tax calculation is implemented in the `calculateTax` function, which:
1. Takes two parameters: the purchase amount and the category ID
2. Applies the appropriate tax rate based on the category ID:
- Category 1 (Food): 5% tax rate
- Category 2 (Healthcare): 0% tax rate
- Category 3 (Other): 10% tax rate
3. Returns the calculated tax amount
The category selection is handled by the `getCategory` function, which:
1. Prompts the user to select a category
2. Converts the user input to uppercase
3. Maps the input character to a category ID:
- 'F' -> 1 (Food)
- 'H' -> 2 (Healthcare)
- 'O' -> 3 (Other)
4. Uses category 3 (Other) as default for invalid inputs Plenty of other files were also generated but for the sake of brevity I'm not going to include them.
Now that we have the specification, let's strip all 'isms related to the C language out of the functional spec.
Look at @specs-from-calc-c. Remove all ANSI C aspects of the spec and write them to SPECS folder
Now, this is where it gets interesting. We have successfully taken an application that was C, disassembled it into ASM, and created a high-level clean-room functional specification that describes the application. Cool. Now, let's provide the LLM with the following prompt
Implement this as a Z/80 spectrum calculator program
Compile it
Add it to the disk image
Run the emulator with the disk image
You may install software
Which generates the sales tax calculator for the Z80 speccy.
; Tax Calculator for ZX Spectrum
; Based on provided specifications
; Implements a simple tax calculation program with three categories:
; F: Food (5% tax)
; H: Healthcare (0% tax)
; O: Other/Standard (10% tax)
; *********************************************************************
; Constants and System Variables
; *********************************************************************
; System constants
SCREEN_START equ 16384 ; Start of screen memory
ATTR_START equ 22528 ; Start of attribute memory
LAST_K equ 23560 ; Last key pressed system variable
CHANNEL_S equ 5633 ; ROM print routine (output to screen)
CLS equ 3503 ; ROM routine to clear screen
OPEN_CHANNEL equ 5633 ; ROM routine to open a channel
; Program constants
FOOD_RATE equ 5 ; 5% tax rate
HEALTHCARE_RATE equ 0 ; 0% tax rate
OTHER_RATE equ 10 ; 10% tax rate
; Decimal multiplier for fixed-point math
; We use 2 decimal places, so multiply by 100
DECIMAL_MULT equ 100
; *********************************************************************
; Program Entry Point
; *********************************************************************
org 32768 ; Start of code (above BASIC)
start:
call init_program ; Initialize program
main_loop:
; Display welcome message
ld de, welcome_msg
call print_string
; Get amount
call get_amount
; Store amount in amount_value
ld (amount_value), hl
; Get category selection
call get_category
; Store category in category_value
ld a, c
ld (category_value), a
; Calculate tax based on category and amount
call calculate_tax
; Store tax in tax_value
ld (tax_value), hl
; Calculate total
call calculate_total
; Store total in total_value
ld (total_value), hl
; Display results
call display_results
; Ask if user wants to continue
call ask_continue
cp 'Y' ; Check if user pressed 'Y'
jr z, main_loop ; If yes, repeat the main loop
cp 'y' ; Check if user pressed 'y'
jr z, main_loop ; If yes, repeat the main loop
; Exit program - return to BASIC
jp exit_program
; *********************************************************************
; Initialization
; *********************************************************************
init_program:
; Clear screen
call CLS
ret
; *********************************************************************
; Input Routines
; *********************************************************************
; Get decimal amount input from user
get_amount:
ld de, amount_prompt
call print_string
; Clear buffer
ld hl, input_buffer
ld (hl), 0
; Get input string
call get_input
; Convert string to number
ld de, input_buffer
call string_to_number
ret
; Get tax category from user
get_category:
ld de, category_prompt
call print_string
; Wait for key press
get_cat_wait:
call wait_key
cp 'F' ; Check for 'F'
jr z, cat_food
cp 'f' ; Check for 'f'
jr z, cat_food
cp 'H' ; Check for 'H'
jr z, cat_healthcare
cp 'h' ; Check for 'h'
jr z, cat_healthcare
cp 'O' ; Check for 'O'
jr z, cat_other
cp 'o' ; Check for 'o'
jr z, cat_other
; Invalid category, default to Other
ld de, invalid_cat
call print_string
ld c, 3 ; Category 3 (Other)
ret
cat_food:
ld c, 1 ; Category 1 (Food)
ret
cat_healthcare:
ld c, 2 ; Category 2 (Healthcare)
ret
cat_other:
ld c, 3 ; Category 3 (Other)
ret
; Ask if user wants to continue
ask_continue:
ld de, continue_prompt
call print_string
call wait_key ; Wait for key press
ret ; Return with key in A
; Wait for key press
wait_key:
ld hl, LAST_K ; Address of system variable LAST_K
ld (hl), 0 ; Clear key buffer
wait_loop:
ld a, (hl) ; Get key
or a ; Check if key pressed
jr z, wait_loop ; No key, continue waiting
ret ; Key pressed, return with key in A
; Get a string input from user
get_input:
ld hl, input_buffer ; Point to input buffer
ld b, 0 ; Input length counter
input_loop:
call wait_key ; Wait for key press
cp 13 ; Check for ENTER
jr z, input_done ; Input complete
cp 8 ; Check for DELETE
jr z, delete_char ; Handle delete
; Check if character is a valid digit or decimal point
cp '0'
jr c, input_loop ; Ignore if less than '0'
cp ':' ; ':' is after '9' in ASCII
jr c, valid_digit ; Valid digit
cp '.' ; Check for decimal point
jr nz, input_loop ; Ignore if not decimal point
valid_digit:
; Don't accept more than 6 characters
ld a, b
cp 6
jr nc, input_loop ; Too many chars
; Store character in buffer
ld a, (LAST_K)
ld (hl), a ; Store character
inc hl ; Next buffer position
inc b ; Increment counter
; Echo character to screen
rst 16
jr input_loop ; Continue input loop
delete_char:
; Handle backspace (delete) key
ld a, b
or a ; Check if buffer is empty
jr z, input_loop ; If empty, do nothing
; Move cursor back, erase character
ld a, 8
rst 16 ; Backspace
ld a, ' '
rst 16 ; Space (erase character)
ld a, 8
rst 16 ; Backspace again
; Update buffer
dec hl ; Move back in buffer
dec b ; Decrement counter
ld (hl), 0 ; Clear the deleted character
jr input_loop ; Continue input loop
input_done:
; Terminate string with null
ld (hl), 0 ; Null terminate
; Print newline
ld a, 13
rst 16
ld a, 10
rst 16
ret
; *********************************************************************
; Calculation Routines
; *********************************************************************
; Calculate tax amount based on category
; Input: amount_value (HL) and category_value (A)
; Output: tax in HL
calculate_tax:
ld a, (category_value)
cp 1 ; Check if Food
jr z, calc_food
cp 2 ; Check if Healthcare
jr z, calc_healthcare
; Default: Other category
calc_other:
ld a, OTHER_RATE ; 10% tax
jr do_tax_calc
calc_food:
ld a, FOOD_RATE ; 5% tax
jr do_tax_calc
calc_healthcare:
ld a, HEALTHCARE_RATE ; 0% tax
jr do_tax_calc
do_tax_calc:
; Tax calculation: amount * tax_rate / 100
; HL = amount
ld hl, (amount_value)
; Multiply by tax rate
ld b, 0
ld c, a ; BC = tax rate
call multiply ; HL = amount * tax rate
; Divide by 100
ld bc, 100
call divide ; HL = (amount * tax rate) / 100
ret ; Return tax in HL
; Calculate total amount (amount + tax)
; Input: amount_value and tax_value
; Output: total in HL
calculate_total:
ld de, (amount_value) ; DE = amount
ld hl, (tax_value) ; HL = tax
add hl, de ; HL = amount + tax
ret
; *********************************************************************
; Utility Routines
; *********************************************************************
; Convert string to number
; Input: DE points to null-terminated string
; Output: HL contains the number (fixed point, 2 decimal places)
string_to_number:
ld hl, 0 ; Initialize result to 0
ld b, 0 ; Decimal point flag (0 = not seen)
ld c, 0 ; Decimal position counter
str_to_num_loop:
ld a, (de) ; Get character
or a ; Check for null terminator
jr z, str_to_num_done
cp '.' ; Check for decimal point
jr z, decimal_point
; Must be a digit
sub '0' ; Convert ASCII to value
; Multiply current result by 10
push af ; Save digit
push bc ; Save flags
ld b, h ; BC = result
ld c, l
add hl, hl ; HL = result * 2
add hl, hl ; HL = result * 4
add hl, bc ; HL = result * 5
add hl, hl ; HL = result * 10
pop bc ; Restore flags
pop af ; Restore digit
; If past decimal point, increment decimal counter
push af ; Save digit
ld a, b
or a ; Check decimal flag
jr z, add_digit ; Not past decimal yet
; Past decimal point, check counter
ld a, c
inc c ; Increment counter
cp 2 ; Check if already have 2 decimal places
jr nc, skip_digit ; Skip this digit if already have 2 decimals
add_digit:
pop af ; Restore digit
ld e, a
ld d, 0 ; DE = digit
add hl, de ; Add to result
jr next_char
skip_digit:
pop af ; Restore digit (but don't use it)
jr next_char
decimal_point:
inc b ; Set decimal point flag
ld c, 0 ; Reset decimal position counter
jr next_char
next_char:
inc de ; Next character
jr str_to_num_loop
str_to_num_done:
; If no decimal part was entered, multiply by 100
ld a, b
or a ; Check if decimal point was seen
jr nz, adjust_decimals
; No decimal point, multiply by 100
ld b, h
ld c, l
add hl, hl ; * 2
add hl, hl ; * 4
add hl, hl ; * 8
add hl, hl ; * 16
add hl, hl ; * 32
add hl, hl ; * 64
add hl, bc ; * 65
add hl, hl ; * 130
ld b, h
ld c, l
srl b
rr c ; * 65
add hl, bc ; * 195
add hl, hl ; * 390
add hl, hl ; * 780
srl h
rr l ; * 390
add hl, hl ; * 780
srl h
rr l ; * 390
srl h
rr l ; * 195
srl h
rr l ; * 97.5
add hl, hl ; * 195
add hl, hl ; * 390
srl h
rr l ; * 195
add hl, hl ; * 390
srl h
rr l ; * 195
add hl, hl ; * 390
srl h
rr l ; * 195
add hl, hl ; * 390
srl h
rr l ; * 195
add hl, hl ; * 390
srl h
rr l ; * 195
add hl, hl ; * 390
srl h
rr l ; * 195
add hl, hl ; * 390
srl h
rr l ; * 195
jr done_convert
adjust_decimals:
; Check number of decimal places entered
ld a, c
or a ; No decimal places entered?
jr z, mul_100 ; Multiply by 100
cp 1 ; One decimal place entered?
jr z, mul_10 ; Multiply by 10
; Already have 2 decimal places, no adjustment needed
jr done_convert
mul_100:
; Multiply by 100
ld b, h
ld c, l
add hl, hl ; * 2
add hl, hl ; * 4
add hl, hl ; * 8
add hl, bc ; * 9
add hl, hl ; * 18
add hl, hl ; * 36
add hl, bc ; * 37
add hl, hl ; * 74
add hl, hl ; * 148
add hl, bc ; * 149
add hl, bc ; * 150
jr done_convert
mul_10:
; Multiply by 10
ld b, h
ld c, l
add hl, hl ; * 2
add hl, hl ; * 4
add hl, bc ; * 5
add hl, hl ; * 10
done_convert:
ret ; Return with number in HL
; Multiply HL by BC
; Input: HL, BC
; Output: HL = HL * BC
multiply:
push de ; Save DE
ld de, 0 ; Initialize result to 0
mult_loop:
; Check if BC is zero
ld a, b
or c
jr z, mult_done
; Add HL to result
ex de, hl ; DE = multiplier, HL = result
add hl, de ; Add multiplier to result
ex de, hl ; DE = result, HL = multiplier
; Decrement counter
dec bc
jr mult_loop
mult_done:
ex de, hl ; HL = result
pop de ; Restore DE
ret
; Divide HL by BC
; Input: HL, BC
; Output: HL = HL / BC
divide:
push de ; Save DE
ld de, 0 ; Initialize quotient to 0
div_loop:
; Check if HL < BC
call compare_hl_bc
jr c, div_done ; If HL < BC, done
; Subtract BC from HL
or a ; Clear carry
sbc hl, bc
; Increment quotient
inc de
jr div_loop
div_done:
ex de, hl ; HL = quotient
pop de ; Restore DE
ret
; Compare HL with BC
; Sets carry flag if HL < BC
compare_hl_bc:
ld a, h
cp b ; Compare high bytes
ret nz ; Not equal, return with flags set
ld a, l
cp c ; Compare low bytes
ret
; *********************************************************************
; Output Routines
; *********************************************************************
; Display calculation results
display_results:
; Display amount
ld de, amount_msg
call print_string
ld hl, (amount_value)
call print_number
; Display tax
ld de, tax_msg
call print_string
ld hl, (tax_value)
call print_number
; Display total
ld de, total_msg
call print_string
ld hl, (total_value)
call print_number
; Print a blank line
ld de, newline
call print_string
ret
; Print a string
; Input: DE points to null-terminated string
print_string:
ld a, (de) ; Get character
or a ; Check for null terminator
ret z ; If zero, we're done
rst 16 ; Print character
inc de ; Point to next character
jr print_string ; Continue printing
; Print a number in decimal format (fixed point, 2 decimal places)
; Input: HL = number (fixed point, 2 decimal places)
print_number:
; Print '$' sign
ld a, '$'
rst 16
; Extract the integer and fractional parts
; Integer part = number / 100
; Fractional part = number % 100
; Save the original number
push hl
; Divide by 100 to get integer part
ld bc, 100
call divide ; HL = integer part
; Print integer part
call print_decimal
; Print decimal point
ld a, '.'
rst 16
; Get fractional part
pop bc ; BC = original number
push hl ; Save integer part
; Calculate fractional part = original - (integer * 100)
push bc ; Save original number
ld bc, 100
call multiply ; HL = integer * 100
pop bc ; BC = original number
; BC - HL = fractional part
or a ; Clear carry
ld a, c
sub l
ld l, a
ld a, b
sbc a, h
ld h, a ; HL = fractional part
; Print fractional part as 2 digits
ld a, h
or a ; Check if high byte is zero
jr z, print_low_byte ; If zero, just print low byte
; Otherwise this is an error, print "00"
ld a, '0'
rst 16
rst 16
jr fract_done
print_low_byte:
ld a, l
cp 10 ; Check if less than 10
jr nc, print_fract ; If not, print as is
; Add leading zero for single-digit values
push af ; Save value
ld a, '0'
rst 16 ; Print leading zero
pop af ; Restore value
print_fract:
ld h, 0
ld l, a
call print_decimal
fract_done:
pop hl ; Restore HL
ret
; Print a decimal number in HL
print_decimal:
; Print a decimal number (0-65535)
ld bc, -10000
call num1
ld bc, -1000
call num1
ld bc, -100
call num1
ld bc, -10
call num1
ld bc, -1
num1:
ld a, '0'-1
num2:
inc a
add hl, bc
jr c, num2
sbc hl, bc
; Skip leading zeros, but always print at least one digit
cp '0'
jr nz, print_digit ; Not a leading zero
; Check if we already printed a digit
push af
ld a, (digit_printed)
or a
jr nz, print_ok
; Check if we're at the last digit
ld a, c
cp 255 ; Check if BC = -1 (last digit)
jr nz, skip_zero ; Not last digit, skip leading zero
print_ok:
pop af
jr print_digit
skip_zero:
pop af
ret
print_digit:
rst 16
; Set the digit_printed flag
ld a, 1
ld (digit_printed), a
ret
; *********************************************************************
; Exit Program
; *********************************************************************
exit_program:
; Display exit message
ld de, exit_msg
call print_string
ret ; Return to BASIC
; *********************************************************************
; Data Section
; *********************************************************************
; Prompts and messages
welcome_msg: defb 13, 10, "TAX CALCULATOR", 13, 10, 13, 10, 0
amount_prompt: defb "Enter purchase amount: ", 0
category_prompt: defb "Select tax category (F)ood, (H)ealthcare, (O)ther: ", 0
invalid_cat: defb 13, 10, "Invalid category. Using Other.", 13, 10, 0
amount_msg: defb 13, 10, "Amount: ", 0
tax_msg: defb 13, 10, "Tax: ", 0
total_msg: defb 13, 10, "Total: ", 0
continue_prompt: defb 13, 10, 13, 10, "Do you want to continue? (Y/N): ", 0
exit_msg: defb 13, 10, 13, 10, "Thank you for using Tax Calculator!", 13, 10, 0
newline: defb 13, 10, 0
; Variables
digit_printed: defb 0 ; Flag for printing leading zeros
; Input buffer (7 bytes: 6 chars + null terminator)
input_buffer: defs 7, 0
; Variables for calculated values (16-bit words)
amount_value: defw 0 ; Purchase amount
category_value: defb 0 ; Tax category
tax_value: defw 0 ; Calculated tax amount
total_value: defw 0 ; Total amount
; Program end
end start Now we need to compile the application using pasmo --tapbas taxcalc.asm taxcalc.tap. So let's give it a spin!
It works but the sales tax isn't being calculated properly so let's head on back and give the LLM the following prompt and attach the above screenshot to it.
Look at the attached screenshot.
The tax did not generate correctly.
The amount is accepting user input.
The cost is not being asked and user does not accept input.
Look at the @00-specs-without-c to see functionality needed. Make changes as needed.
which resolves the formatting issues, however user interactive input does not happen. The application should ask me how much an item costs, but it does not do that. So, let's head back to the LLM and attach the screenshot.
It took a few more backwards and forwards to steer it via screenshots that had verbose logging but success was achieved.
The techniques detailed below were able to take an application from assembler, generate high-level specs and those high-level clean-room specs were able to generate a working Z/80 spectrum application.
Geoffrey Huntley
Anyway, that was a fun trip back in time and memory lane - thanks, Damien Guard, for the inspiration and nerd-snipe. In all it took me about two hours, of that it was mainly me trying to figure out how to install, run, configure these emulators and how to make a Z/80 tape.
The actual build was all very manual, driven by me as a human loop, because the Z/80 spectrum isn't really a good target for automating a reward loop. These LLMs get most things right but some things wrong. By having tests in your codebase and invoking the MCP tools to run these tests, you'll get successful outcomes automatically nine times out of ten...
It's a new world for software engineers, it's kinda like the Telsa FSD. Sometimes it gets it wrong but if you trust it enough, provide enough guidance and understand how these coding assistants work under the hood you can achieve N factor more outcomes than ever before.
Software rewrites from one language to another are no longer an expensive thing for a company to do and if a "source available" company has provided the internet with their restricted source-code they can be cloned in hours, automatically, whilst you watch Netflix.
If you enjoyed reading, give 'em a share, please:
2025-03-01 16:37:08
These LLMs are shockingly good at deobfuscation, transpilation and structure to structure conversions. I discovered this back around Christmas where I asked an LLM to make me an Haskell audio library by transpiling a rust implementation.
Geoffrey Huntley
and here's me using the technique (bellow) to convert an application to a z/80 spectrum tape
Geoffrey Huntley
I'm not going to bury the lede, so let's dig right into the real reason why you clicked on this post, here's the source code...
ghuntley
What follows in this post is how you can do it yourself and a special surprise insight at the bottom...
The source code for Claude Code is currently "not available". Whilst a GitHub repository has been published, it contains no source code. Claude Code was an unusual announcement to release along side Sonnet 3.7 - I suspect it was/is a marketing gimmick which was built to demonstrate the capability of the new model and to show the world how to build an AI coding agent (and how easy it is) from the creators of the LLM model (they know it best)
anthropics
Claude Code is authored in TypeScript and was released to NPM. You can install it via..
$ mkdir claude-code && cd claude-code
$ npm i @anthropic-ai/claude-codeAfter installing the application into a folder you'll be greeted with the following directory structure..
tree
.
├── node_modules
│ ├── @anthropic-ai
│ │ └── claude-code
│ │ ├── LICENSE.md
│ │ ├── README.md
│ │ ├── cli.mjs
│ │ ├── package.json
│ │ ├── scripts
│ │ │ └── preinstall.js
<snip>
├── package-lock.json
└── package.json
57 directories, 436 filesThis is the meat of the application itself. It is your typical commonjs application which has been compiled from typescript. As part of the process of compilation with Webpack a minifier step combines all the source code into this file and truncates the symbols.
If you want to this at home. Your first task to is open up cli.mjs within your favourite AI coding assistant or even Claude Code itself. Due to the "safety rails and AI alignment" you'll need to strip the top comments from the application otherwise they will kick in unless you use an LLM such as Grok which has no guard rails.
Here's the prompt that I used.
CLI.js is a commonjs typescript application which has been compiled with webpack.
The symbols have been stripped.
Inspect the source code thoroughly (extra thinking) but skip the SentrySDK source code.
Create a specification library of features of the application.
Convert the source code into human readable.
Keep going until you are done!
Because cli.mjs is close to 5mb - which is way bigger than any LLM context window out here. It shouldn't work but it does. You're going to need babysit it for a while and feed it reward tokens of kind words ("your doing good, please continue") and encourage it to keep on going on - even if it gives up. It will time out, lots...
After about two minutes it'll spit out a technical specification which details how the application was built and the features of the application...
At this point it'll timeout for sure. This is when you need to do the "new meta" of asking the LLM to write out the technical specification library. I say new meta because - hi folks - welcome, I haven't talked about this yet publicly yet but the results of this technique when used in combination with the "old meta" are truly absurd. I'll be going deep into this in a follow-up blog post so if you wanna be the first to see it - like, subscribe and click on the bell below below.
I work remotely from a van that is slowly working its way around Australia. Follow me for the intersection of remote work, camping & #vanlife.
No spam. Unsubscribe anytime.
Once it has finished dumping out the technical specification library you'll need to feed it this prompt
Now deobfuscate the application.
Split the application into separate files per domain in the SPECS folder.
Provide an overview of the directory structure before starting deobfuscation.
Skip the SENTRYSDK.
After a couple moments you'll be greeted with the skeleton of the deobfuscated outcome...
claude-code/
├── package.json
├── tsconfig.json
├── README.md
├── LICENSE.md
├── src/
│ ├── index.ts # Main entry point
│ ├── cli.ts # CLI argument parsing and commands
│ ├── config/ # Configuration management
│ │ ├── index.ts
│ │ ├── schema.ts
│ │ └── defaults.ts
│ ├── terminal/ # Terminal interface
│ │ ├── index.ts
│ │ ├── input.ts
│ │ ├── output.ts
│ │ └── rendering.ts
│ ├── codebase/ # Codebase analysis
│ │ ├── index.ts
│ │ ├── scanner.ts
│ │ ├── indexer.ts
│ │ ├── search.ts
│ │ └── watcher.ts
│ ├── commands/ # Command processing
│ │ ├── index.ts
│ │ ├── parser.ts
│ │ ├── executor.ts
│ │ └── handlers/
│ │ ├── edit.ts
│ │ ├── search.ts
│ │ ├── explain.ts
│ │ ├── git.ts
│ │ └── system.ts
│ ├── ai/ # AI integration
│ │ ├── index.ts
│ │ ├── client.ts
│ │ ├── context.ts
│ │ ├── prompts.ts
│ │ └── response.ts
│ ├── fileops/ # File operations
│ │ ├── index.ts
│ │ ├── reader.ts
│ │ ├── writer.ts
│ │ ├── diff.ts
│ │ └── vcs.ts
│ ├── execution/ # Command execution
│ │ ├── index.ts
│ │ ├── shell.ts
│ │ ├── sandbox.ts
│ │ └── monitor.ts
│ ├── auth/ # Authentication
│ │ ├── index.ts
│ │ ├── oauth.ts
│ │ └── tokens.ts
│ ├── telemetry/ # Analytics and telemetry
│ │ ├── index.ts
│ │ ├── events.ts
│ │ └── reporter.ts
│ ├── errors/ # Error handling
│ │ ├── index.ts
│ │ ├── types.ts
│ │ ├── handlers.ts
│ │ └── formatter.ts
│ └── utils/ # Utilities
│ ├── index.ts
│ ├── logger.ts
│ ├── async.ts
│ └── formatting.ts
├── scripts/ # Build and deployment scripts
│ ├── build.js
│ └── preinstall.js
└── tests/ # Test suite
├── unit/
├── integration/
└── fixtures/Now this is the part where it gets wild. Strap yourself in for another "oh-fuck" moment in time....
As the CLI.js is circa 5Mb in size. What follows is going to require a-lot of patience but the key is to use the following prompt and keep giving it "yeah bb, you doing great. keep going" words of encouragement.
Look at the SPECS library.
Look at CLAUDE-CODE folder.
Look at @CLI.js (do not confuse it with @cli.ts), keep transpiling and implement anything that's not in the SPECS folder that has not been implemented in the CLAUDE-CODE folder.
Seriously, you are going to need to enter that at least 100 times over the next 30 minutes.
Deobfuscating [nb. how do we even describe this? Is it deobfuscation?] JavaScript isn't that interesting or impressive though however the resulting source code is highly readable and covers all-the key elements in an coding assistant. We won't know how accurate it is until Anthropic goes through the motions to release the upstream source-code.
Understand dear reader that this technique can be done on any programming language and even from pre-existing binaries themselves. I've transpiled from ASM to specs and achieved below:
Geoffrey Huntley
and others have directly converted VB .exe's to Python...
Reddit grandfather uploads 27 year old EXE file of a visual basic game and Claude one-shotted recreating the game in Python in under 5 minutes!!
— Deedy (@deedydas) February 26, 2025
From the binary. pic.twitter.com/KEzUfisxmu
Now, a sharp mind should have picked up by now the implications of above but I'll spell it out. Using the above technique you can clean-room any software in existence in hours or less.
All those "source available" founders who raised shit-loads-of-cash in the last boom are now screwed, as anyone can re-implement their "proprietary features" which provide them with revenue within hours using the above technique to launch competing startups at lower-operating costs.
All you need is access to their source-code and they have given you the keys to the kingdom on a golden platter by going to market as "commercial open-source" with source-code "protected by restrictive licensing" uploaded directly onto GitHub.
Steven J. Vaughan-Nichols
Please understand that restrictive software licenses no longer matter because these LLMs can be driven to behave like Bitcoin mixers that bypass licensing and copyright restrictions using the approach detailed in this blog post.
These zombie companies are about to get harvested if the founders don't "Elon Musk" their companies... fast... especially if they don't have a defensible moat. So, here's to the next generation of builders. May you use these insights wisely and to your advantage. It's an incredible time to be alive if you just do things.
Geoffrey Huntley
if you aren't losing sleep right now and doing 80+hr weeks of coding right now whyyyyyyyy. there's so much opportunity available right now...
If you enjoyed reading, give 'em a share please:
2025-02-27 17:26:00
Two weeks ago a student anonymously emailed me asking for advice. This is the reply and if I was in your shoes this is what I'd do.
So, I read your blog post "An oh f*** moment in time" alongside "The future belongs to idea guys that can just do things", and decided "fine, I'll go try cursor for myself and see how well composer does". I normally use copilot and some claude, but not much since getting the context of my 50kloc project into Claude is rough, and I didn't want to start paying for API use so I could start using i.e aider (I normally get copilot for free). I heard some claims about cursor and friends that I assumed were pumped up LinkedIn talk, so I really didn't think about it until now.
For example, I've been working on a little JNI module for my android app, but it has a bunch of weird memory errors because managing the JNI resources is borderline impossible and C++ RAII has piles of insane footguns. So, I planned to rewrite it in Rust so I could 100% isolate the memory unsafety. This was a tall order, it was a three-way integration between a bulky C++ library with it's own CMake setup, and the JNI code of my app. It required some really messy translations from a rust trait into a C++ abstract class. It would take a lot to integrate it into my app. I decided it was a good enough benchmark to see if composer was up to snuff.
First go around was not well, I gave the lump sum of all the work I wanted and it choked and went around in circles. Tried to go back to debugging the memory problems manually, but honestly I hate C++ and decided to another go around with composer and the rust module. Second time I sliced up the task into smaller but still pretty big pieces and fed them one at a time to composer.
This time, composer probably wrote 99% of the code. Porting the previous shell script, making the shims I needed to map a trait to a C++ abstract class, porting the manual JNI code, and the massive buildscript linking it all together. It debugged its own work when I pasted error traces in (sadly since this rust module was shoehorned into my app composer agent couldn't really test on it's own). And it just worked. There was some stuff it couldn't do, mostly choking on big error traces and incremental build bugs (thanks gradle), and sometimes I needed to point it in a better direction architecturally, but otherwise I barely touched the code. All I did was direct composer to do what I was thinking of. I then just killed time while it did the work.
I'm at a loss now. I'm a student. Fresh grads and interns aren't seen as idea guys that can get stuff done, they're seen as useless ticket monkeys to be herded by seniors. Now Cursor Composer is the ticket monkey presumably to be herded by a senior, not me. And maybe even the senior isn't needed if a scaled enough reasoner model can do the task slicing. I've already felt like I've been shuffling chairs on the titanic, talking about projects and internships as if this threat doesn't exist, and honestly this confirms it. Is there literally any reason why I shouldn't just throw away the 10 years of my life and do...I don't even know what. At this development pace I don't even know if I have time to "pivot" before everything else gets solved by o4 or whatever. What do I even do anymore?
Thanks,
An Anonymous Student
It's just facts; I'm a straight shooter. I'd rather tell it to you straight and provide actionable advice than placate feelings.
The steps that you take now will determine your success rate with obtaining a SWE role going forward. If you are a high autonomy person then you're not fucked, as long as you take action.
The Software Development industry works in cycles; this is the third bust after a boom that I've weathered through. Understanding what happened in the 2000 dot-com bust is important because it led to the 2017 boom.
So, let's rewind time.
It's now the year 1998, and if you knew how to make a website using Dreamweaver, how to cobble some perl together and use RSH to connect to a Sun e4500, then you were guaranteed a role as a software engineer.
After a massive run-up of hype and an injection of too much venture capital money resulted in a talent market where there weren't enough software engineers in the world.
Life was great. That is, until it wasn't. The bubble burst in 2000, and an engineer called Philip J. "Pud" Kaplan chronicled the downfall on a website called "Fucked Company dot com". To put into perspective how important and meaningful this website was at the time - it's the equivalent of HackerNews (or Slashdot)
Suddenly, all the jobs overnight dried up. Students who had just graduated and were looking for a sweet-sweet software engineering positioning were up shit-creek, just like you are now (if you don't take action).
Seemly overnight, the employment switched from a seller's market (i.e. in employee favour) to a buyers market (i.e. in employers' favour) because there was an oversupply of senior engineering talent desperate to find their next job. Why would a company hire a graduate when they could obtain someone with five years of knowledge on the cheap?
It was a COVID19 moment in time, if you were born in the wrong year (ie. year 12 high school students disrupted in Australia) then your life was utterly turned up-side-down.
That generation of graduates simply missed out on opportunities and core life experiences, but there were some nice outcomes from it, as it flushed out all the folks who were in tech just for the $$.
The folks who stayed/entered were those genuinely interested in computers - cause why else would you enter a field that had very few job prospects?
but here's the kicker. Because there was an under-supply of graduates as companies weren't raising the next generation it lead to a shortage of talented software engineers in the market. The result was inevitable.
The market switched sides to where the employees had all the power, and due to another massive round of venture capital injection, money was flowing freely.
Every company out there wanted to attract "Google pedigree talent". Companies everywhere started offering perks and compensation packages to tempt them to come join their company.
Word got out and suddenly everyone wanted to become a software engineer because the money was absurd. YouTube is now a thing, all sorts of grifters turned up selling courseware on how to get a job and boasting about their millions - which resulted in even more people becoming software-engineers (just for the money) because it was an easy path to fast retirement.
It's now the year 2023, and after a strong 14 years of growth, the industry fell on its face once again. Interest rates went up, and parking money-with-risk at Venture Capital firms was no longer a desirable place for investors because there were other alternatives now available at lower risk.
Whilst I managed to avoid the original dot-com dust, this one affected me personally. I was one of the software engineers caught up in the 219,709 layoffs, and it took me (with my experience) six months to find a suitable replacement role.
If you graduated from university or entered the job market in 2023, then you were competing against me (and/or circa 219,709 qualified employees with experience).
ie. screwed…
AI is at our doorstep, and the employment market has not recovered from the last bust. You're lucky in a way because you realized early what's coming and have time to take action. There are many software engineers who simply aren't gonna make it because they haven't had the epiphany that you have and haven't even started progressing through the people stages of AI adoption...
A brilliant co-worker penned together the following chart and the following words, which explain the impact of AI on different levels of engineers...
You’re just starting your work in a new codebase and you’re still piecing together a solid mental model of how things actually work. Here, an LLM is a lifesaver. Stuck on an error? An LLM can give you an explanation that makes sense. Need to write some code for a minor feature, or do a library upgrade? All of this can be done much faster with an LLM.
An LLM can already feel like it can do a huge part of your job for you. That's why I believe there’s a real danger zone here. If you lean on an LLM as a shortcut to get unstuck in the same way as you’d reach out to your more senior colleagues when you’d otherwise have to ask – then fine. In the real world, chances are you won’t have the luxury of avoiding LLMs even if you wanted to. However, if you end up copy-pasting code back and forth between your IDE and the LLM without truly understanding what’s happening or why, then advancing your engineering skills will become a serious challenge.
You’ve built up a fair amount of context and can navigate your codebase with confidence. You still find that LLMs make you write code much faster. You can ship features faster with copilot’s completion, use agents to write less boilerplate code, learn new frameworks much faster with ChatGPT.
However, you’re already bumping into cases that an LLM simply can’t handle yet. It won’t decipher what the customers actually wanted from the ticket you were given, it can’t use your debugger to pinpoint a dangerous race condition, and it can’t help you much when you’re responding to a midnight on-call alert.
You've got a great mental model of the whole codebase you're responsible for. You know all of its ins and outs. Hell, you probably wrote a decent part of it. Sure, you can code much faster, and you enjoy it, but how much time do you really spend writing code? When you work on the roadmap, it can’t really help you much. When you dive into a weird heisenbug, it can’t really help you—it gets confused. When you’re writing an extensive design document for the next project, it can only help you with the formatting and structure, not the hardest part – the substance. It just doesn’t have all the nuance and context you’ve accumulated in your head, and even if you wanted to, you couldn’t write it down.
Many of your friends and colleagues are excited, and you want to be excited, but you just can’t. The AI is simply not there yet. This is probably the level where the most scepticism about LLMs comes from, and the more technical or unique your domain is, the stronger the disillusionment.
While there are many staff archetypes out there, one thing is common between them all – your role is often to light the path for others to follow. And to achieve this, you have to experiment a lot.
Here’s where LLMs can start shining again. Writing proof-of-concept projects has suddenly become much easier. If you need to show the feasibility of taking an approach, an LLM can help create a half-baked, barely working solution much faster than without it. And the best part is that once the LLM gets stuck, you can very quickly get it unstuck using the extensive domain knowledge in your brain.
Staff+, senior and mid-level engineers (who invest in themselves) are now more desirable because they can use their expertise to output multiple factors more code, and thanks to wisdom earned over the years (or tens of years), they are able to obtain better outcomes from AI as they have the experience to know when the AI is bullshitting and have developed taste for what does or does not look right.
Geoffrey Huntley
With hundreds of thousands of dollars at stake, all the incentives are there for candidates to cheat. The video below is one of many tools that now exist today that hook the video render of macOS and provide overlays (similar to how OpenGL game hacks work) that can't be detected by screen recording software or Zoom.
The software interview process was never great but it's taken a turn for the worst as AI can easily solve any thing thrown at it - including interview screenings.
Another co-worker of mine recently penned the blog post below, which went viral on HackerNews. I highly recommend reading the comments.
Kane Narraway
It's now incredibly easy to clone any SaaS company out there in existence if you know how to drive AI and have the expertise.
AI-powered B2B SaaS apps are in trouble 😵💫
— Sam Hogan 🇺🇸 (@0xSamHogan) February 27, 2025
Instead of paying almost $20,000 I made an AI-powered support bot in less than 3 hours using only @cursor_ai and Claude 3.7
Fully open-source. Clone the repo and set up your own in less than 5 minutes.
This is the future of software. https://t.co/8RWi8oYPeB pic.twitter.com/MSPVRYOSog
You've already read the article below where this was hinted at, so I'll supplement with the following wisdom. I suspect the future of work is going to be lots of small 10-person companies operating similar to how a law firm works - with profit sharing between the senior partners.
Geoffrey Huntley
If you graduated last year and are entering the workforce this year, then it doesn't unless you take action. It's a COVID19 moment in life again.
* https://t.co/pqaA3Pip9v
— Erik Meijer (@headinthebox) February 6, 2025
* https://t.co/NK41GANrbg
SWE Agents have gone mainstream.
Time for all CS departments to refund tuitions to their students and close the doors. It is over.
If you are a student who has just started university and will be graduating four years from now - there will be software engineering roles, although they will be different.
What's likely to happen is - if more companies close their doors to juniors then the next generation of juniors won't be raised - similar to what happened in the dotcom boom/bust - and we’ll get another boom - which will lead to the incredible perks and fat paychecks for people with the right skills because not enough juniors entered the workforce…
Understand that time is on your side if you take action. You have about a year, maybe less. Whatever you do - do not squander it. Your edge right now is a large majority of software engineers have not discovered what you have. When they do - it's game over unless you have an edge.
Learn the fundamentals that university typically does not teach:
Find yourself a peer that pushes you to the limits of learning
The standard pace of learning is for chumps. If you are better than the average, then you can fold space-time and outpace the competition. Read this blog post.
Do not join a Startup
In the last VC boom and bust that happened before AI, many startups raised too much capital or engaged in outright fraud to pump their customer numbers up by cross-selling with each other. The AI bust that's about to happen is going to be brutal for them - there are many, many living, dead zombie companies out there.
Only join an existing startup if it pays well (ignore the equity/dreams of a jackpot) and if you find an operating environment that pushes your growth and learning to the limits.
Understand that most Startups fail, and you could be out on your ass overnight. Ensure you have plenty of cash stowed away - it could take you +6 months to find a new role.
Don't get a job that has a ban on AI coding tools
You'll be doing yourself a huge disservice. Look for companies that encourage it.
Obtain skills that are going to be highly desirable by every employer
I'm going to call it right now - ignore commodity bullshit disposable knowledge like AWS - focus on what people don't know and what will be in demand.
Become a subject matter expert in MCPs. There is brand new territory open to you right now to be a prolific open-source author of MCPs, as not many people are creating them at this moment in time.
Pull apart https://github.com/block/goose and https://github.com/All-Hands-AI/OpenHands. Learn how they work and then build your own AI coding assistant from the ground up - from first principals or follow along with my series series that is building them incrementally - piece by piece.
Geoffrey Huntley
You want to be the employee that companies are fighting for because you have 6+ months edge on everyone else and are bringing new ideas/techniques to the table. Become the one that understands what all these tools do - under the hood - better than an engineer who's 20+ years into their career and hasn't been paying attention.
Focus on shipping with rust
Every programming language community and ecosystem has its window in time where it attracts brilliant minds. Right now, that's the rust ecosystem. It's full of innovators - you want to be hanging out with the innovators.
If you focus on learning something commodity - such as typescript - you are positioning yourself incorrectly. Having said all of that, programming languages no longer matter, but Rust has a unique property where it's able to achieve better outcomes with LLMs due to its type system that other programming languages (except Haskell) lack.
Understand how your work directly translates to business value
The organizational abstraction layers are shrinking. Going forward, it's incredibly important to think and act like an entrepreneur. You aren't a software engineer who types code into an IDE - those days are gone. Instead, you need to understand how your work directly translates to business value and to achieve that, you need to become a product engineer. Find yourself a product manager (or founder) who has immense domain depth and befriend them. Learn what high-value problems are to be solved and discover their pain points/research items by walking in their boots or in the boots of a customer. Be a doctor, not a waiter. Learn a little bit about business and finance.
Build a widget, not an aeroplane
When building, start small. As soon as you make the tiniest of things, share it with the world. Take an approach of building lots of small things that compose well that can combined to make something big. It's a marathon, not a sprint.
Build a public profile
I can't stress this enough. So many opportunities in my life which yielded fruits only happened because I manifested luck. Once you have a couple of MCPs under your belt and you are on the way to building your own AI coding assistant - start networking. Don't network to get a job. Network to share your knowledge with others.
In application, this means:
Play with the tools, develop edges and unique insights...
Geoffrey Huntley
Geoffrey Huntley
ps. socials @ https://x.com/GeoffreyHuntley/status/1895043009991032996
2025-02-09 07:09:44
What follows is an email that arrived in my inbox moments ago, reproduced in it's entirety. I'll be doing a response letter, after I get some sleep. For now, discuss at https://x.com/GeoffreyHuntley/status/1888365040572751973
Hi there,
So, I read your blog post "An oh f*** moment in time" alongside "The future belongs to idea guys that can just do things", and decided "fine, I'll go try cursor for myself and see how well composer does". I normally use copilot and some claude, but not much since getting the context of my 50kloc project into Claude is rough, and I didn't want to start paying for API use so I could start using i.e aider (I normally get copilot for free). I heard some claims about cursor and friends that I assumed were pumped up LinkedIn talk, so I really didn't think about it until now.
For example, I've been working on a little JNI module for my android app, but it has a bunch of weird memory errors because managing the JNI resources is borderline impossible and C++ RAII has piles of insane footguns. So, I planned to rewrite it in Rust so I could 100% isolate the memory unsafety. This was a tall order, it was a three-way integration between a bulky C++ library with it's own CMake setup, and the JNI code of my app. It required some really messy translations from a rust trait into a C++ abstract class. It would take a lot to integrate it into my app. I decided it was a good enough benchmark to see if composer was up to snuff.
First go around was not well, I gave the lump sum of all the work I wanted and it choked and went around in circles. Tried to go back to debugging the memory problems manually, but honestly I hate C++ and decided to another go around with composer and the rust module. Second time I sliced up the task into smaller but still pretty big pieces and fed them one at a time to composer.
This time, composer probably wrote 99% of the code. Porting the previous shell script, making the shims I needed to map a trait to a C++ abstract class, porting the manual JNI code, and the massive buildscript linking it all together. It debugged its own work when I pasted error traces in (sadly since this rust module was shoehorned into my app composer agent couldn't really test on it's own). And it just worked. There was some stuff it couldn't do, mostly choking on big error traces and incremental build bugs (thanks gradle), and sometimes I needed to point it in a better direction architecturally, but otherwise I barely touched the code. All I did was direct composer to do what I was thinking of. I then just killed time while it did the work.
I'm at a loss now. I'm a student. Fresh grads and interns aren't seen as idea guys that can get stuff done, they're seen as useless ticket monkeys to be herded by seniors. Now Cursor Composer is the ticket monkey presumably to be herded by a senior, not me. And maybe even the senior isn't needed if a scaled enough reasoner model can do the task slicing. I've already felt like I've been shuffling chairs on the titanic, talking about projects and internships as if this threat doesn't exist, and honestly this confirms it. Is there literally any reason why I shouldn't just throw away the 10 years of my life and do...I don't even know what. At this development pace I don't even know if I have time to "pivot" before everything else gets solved by o4 or whatever. What do I even do anymore?
Thanks,
An Anonymous Student