Two weeks ago I did something that still feels like a mix of magic and mild existential dread. I had been slowly maintaining a Lisp-based language and trying, for years, to integrate Libtorch (the C++ backend of PyTorch) into it. After six months of on-and-off work and a trainee’s help, I had a barebones wrapper that was barely usable. Then I tried an AI-driven approach and, in three days, had what I couldn’t achieve in half a year. This is my personal take on that experience — messy, excited, and a little worried, because this felt like pure vibe coding.
How the project started
Quick background: I build programming languages at my company. My most recent language is a Lisp dialect that’s been evolving for years. In 2020 I decided to expose Libtorch so people could write neural nets directly from our language. Libtorch is powerful, but most examples are in Python via PyTorch. The C++ documentation was thin and inconsistent, and language wrappers for other platforms are often incomplete or closed-source. Six months into the pandemic, with a trainee onboarded, we had a skeletal wrapper that compiled but lacked the breadth and documentation needed for real use.
How vibe coding happened
I was skeptical about AI-written code. I’d spent decades without it. But I set up an agentic workflow: a well-known model (I won’t name it) orchestrated by scripts, with stepwise goals, tests, and automated validations. I gave it the API contracts, some examples of our Lisp constructs, and pointed it at our build system. What happened next was… startling.
What I asked the AI to do
- Generate a complete C++ wrapper for our FFI layer covering key Libtorch types.
- Produce compilation artifacts and CI scripts for macOS and Linux, with GPU and MPS support.
- Create documentation, tutorials, and dozens of runnable examples inside our language.
- Write tests for each binding to ensure parity with the Libtorch API.
What it actually produced
In three days the agent produced a surprisingly coherent package: wrapper code for most important Libtorch features, a basic tutorial, a documentation site skeleton, and hundreds of small test examples that ran locally. The code compiled on macOS and Linux, and it contained scaffolding for MPS and GPU usage. At each step the agent created examples to validate behavior, which sped debugging and uncovered edge cases I’d missed in six months of manual work.
“The AI didn’t just spit code — it reasoned about how to validate, document, and test each piece as it went.”
How I worked with the AI
I didn’t press a button and walk away. This was an interactive, iterative collaboration. I reviewed diffs, adjusted constraints, and nudged it away from unsafe patterns. I added small, focused unit tests and asked for explanations when a behavior seemed odd. The model often included multiple implementation options with pros and cons, then generated tests to show the differences. That helped me choose one path or another quickly.
What the experience felt like
There was a moment — a half hour on night two — when I realized the wrapper did more than just compile. The agent had produced tutorials, examples, and inline documentation that reflected my language’s idioms. It felt like pairing with a junior developer who never got tired and wrote near-production-quality tests. I found myself alternating between excitement at the productivity gains and a deep unease about how fast this happened.
Why this is both amazing and scary
On the amazing side: I achieved in days what took months, with richer documentation and testing. The repurposable examples alone are worth the time, and the wrapper gives our users a straightforward path to leverage Libtorch features from our language.
On the scary side: this changes expectations. Junior developers might get tasked with far more ambitious projects earlier in their careers. The craft of carefully learning APIs by reading source and wrestling with build systems could be abbreviated, for better or worse. If a machine can scaffold a complex integration, what skills will be most valuable going forward? Understanding architecture, system design, and validation probably become even more important, but the path to gaining those skills might shift.
- Speed vs. tacit knowledge: Rapid generation can skip deep, tacit learning.
- Validation risks: Automated tests are great, but they can have blind spots.
- Tooling gaps: The AI needed careful prompts and environment setup to avoid unsafe defaults.
Practical tips if you want to try this
- Start small: define clear, incremental goals for the agent and validate constantly.
- Use tests as checkpoints: Require that each generated piece comes with automated tests.
- Review and restrict: never accept generated code blindly — lint, security-scan, and perform code reviews.
- Document the agent’s decisions: treat its suggestions as proposals that need human sign-off.
Also, be explicit about environment: the model needs build flags, platform targets, and API contracts to reliably deliver cross-platform support. In my case, linking MPS and GPU support required specific toolchain flags the agent wouldn’t guess without examples.
Ethical and career thoughts
If you’re late-career like me, you might feel both relief and unease. Relief because tedious integration tasks can become less painful; unease because the nature of software work is shifting. For younger devs, this can be a powerful leveling tool — but it might also compress the apprenticeship that used to teach debugging, build systems, and low-level troubleshooting.
As a community, we should focus on teaching critical thinking: how to validate outputs, how to define good prompts, how to design tests that reveal subtle failures. Those skills will matter more than rote memorization of library quirks.
Wrapping up
I still feel conflicted. The three-day win was exhilarating: a working Libtorch wrapper, tutorials, and tests in an afternoon. But it also felt like watching an apprentice suddenly perform at the pace of an expert. That shift is powerful and disorienting. If you try this approach, be intentional: guard against silent failures, insist on tests, and teach people how the sausage is made. For better or worse, we just experienced a new mode of development — and whether you call it automation, augmentation, or vibe coding, it’s going to change how we learn and ship software.
Q&A
Q: How did you verify the generated code actually worked?
A: I required runnable tests at each step. The agent produced small, focused examples that compiled and executed on macOS and Linux. I ran CI scripts locally, inspected logs, and added additional unit tests where coverage felt thin.
Q: Won’t this make developers obsolete?
A: Not obsolete. The role shifts. Machines accelerate routine integration and scaffolding, but humans still design architecture, validate edge cases, and decide trade-offs. The emphasis moves toward higher-level thinking, testing, and verification.