Over the past months, I’ve been quietly running a personal experiment in how far modern free AI tooling can take a single developer working outside of their “core stack.”
The outcome surprised even me.
Using the free Windsurf SWE-1.6 model, combined with ChatGPT for early-stage specification design, I was able to build and ship a collection of fully playable, browser-hosted projects — all deployed on GitHub Pages across multiple repositories.
As a professional Cursor user, I came into this with strong expectations. Cursor is, in many ways, a more powerful and mature tool — especially when it comes to deeply integrated, code-first workflows. I’m very used to that environment: writing code, refining it inline, and leveraging AI as an augmentation layer within a traditional development loop.
However, Cursor does not offer a free tier with anything close to the level of access that Windsurf provides. And that difference turned out to matter more than I expected.
Windsurf, particularly with its free SWE-1.6 model, gave me something incredibly valuable: freedom to iterate without thinking about usage limits. That completely changed how I approached building.
Most importantly: I did this after long working hours at my day job, often when I had energy for thinking but not for deep manual coding.
I’m not a JavaScript developer. My understanding is solid, but I'm not familiar with the latest and greatest. In the past, that would have been a limiting factor.
With this workflow, it stopped mattering nearly as much.
The Core Shift: From Coding to Specifying
The biggest change wasn’t the tool — it was the workflow.
Instead of starting with code, I started with:
- Writing a clear human-language specification in ChatGPT
- Translating intent into structured behavior (“what should happen”)
- Feeding that into Windsurf SWE-1.6
- Iterating through feedback loops in natural language:
- “this feels too floaty”
- “make collision detection stricter”
- “optimize for mobile input”
- “fix edge case when cube rotates too fast”
The model handled implementation details. I handled intent, direction, and validation.
This created a loop where I could produce dozens of meaningful iterations in a single evening, often resulting in hundreds of commits across projects over time.
What This Means for Software Engineering
This experience reinforced something I’ve been increasingly convinced of:
We are moving away from software engineering as manual construction, and toward software engineering as system design + specification + validation.
The job is shifting:
- Less time writing boilerplate code
- More time defining clear behavioral intent
- More time reviewing, testing, and steering AI systems
- More emphasis on product thinking and interaction design
In a sense, we’re moving toward an “IKEA model” of software:
- You don’t carve the furniture
- You assemble and refine it
- And you understand how it should fit into a space
There will always be a need for deep craftsmanship — but it will increasingly be applied to critical systems and core primitives, not every app we build.
The Projects
Here’s a breakdown of what I built using this workflow:
📚 Interactive Book Engine
Repo: https://github.com/FranekJemiolo/interactive-book-engine
Live: https://franekjemiolo.github.io/interactive-book-engine
A branching narrative system where stories behave like interactive graphs. Users make choices that dynamically alter progression paths, enabling experimentation with narrative design and replayability.
🧱 Jenga Game
Repo: https://github.com/FranekJemiolo/jenga-game
Live: https://franekjemiolo.github.io/jenga-game
A physics-based 2D Jenga simulation focused on balance, wobble, and collapse dynamics. The emphasis was on believable instability rather than strict realism.
🏎 Driftline Infinite
Repo: https://github.com/FranekJemiolo/driftline-infinite
Live: https://franekjemiolo.github.io/driftline-infinite
An infinite 2D racing/driving prototype exploring procedural track flow, drift mechanics, and continuous camera motion. Designed as a foundation for arcade-style racing systems.
🕵️ Hidden Face Game
Repo: https://github.com/FranekJemiolo/hidden-face-game
Live: https://franekjemiolo.github.io/hidden-face-game
A perception and pattern-recognition game where players must detect hidden or partially obscured visual targets under time pressure.
⌨️ Typing Test
Repo: https://github.com/FranekJemiolo/typing-test
Live: https://franekjemiolo.github.io/typing-test
A lightweight typing speed benchmark tool measuring WPM, accuracy, and error patterns, with simple replayability and performance tracking.
🚦 F1 Reaction Test
Repo: https://github.com/FranekJemiolo/f1-reaction-test
Live: https://franekjemiolo.github.io/f1-reaction-test
A reaction-time game inspired by Formula 1 starts, simulating randomized light sequences and measuring human response latency under uncertainty.
👽 Alien Cognition Game
Repo: https://github.com/FranekJemiolo/alien-cognition-game
Live: https://franekjemiolo.github.io/alien-cognition-game
A logic and pattern inference game designed around “non-human” rulesets, forcing players to adapt to evolving systems rather than learning fixed mechanics.
🅿️ Parkit Game
Repo: https://github.com/FranekJemiolo/parkit-game
Live: https://franekjemiolo.github.io/parkit-game
A parking simulation puzzle focused on spatial reasoning, vehicle movement constraints, and path optimization in tight environments.
Why Windsurf SWE-1.6 Mattered
The key unlock wasn’t just code generation.
It was iteration speed with low cognitive overhead.
Windsurf allowed me to:
- Express changes in plain language
- Avoid context-switching into syntax-heavy debugging
- Rapidly evolve gameplay systems without rebuilding from scratch
- Maintain momentum even after long workdays
Combined with ChatGPT for upfront design clarity, it became a full pipeline:
idea → spec → implementation → feedback → refinement → repeat
Takeaway
This way of building has fundamentally changed how engineers should think about software.
It's no longer about people who primarily write code.
Now they should see themselves as someone who:
- shapes systems
- defines behavior
- and continuously refines AI-assisted implementations
The barrier to shipping ideas has dropped dramatically.
And that shift is not just technical — it’s structural. It changes who can build, what can be built, and how fast iteration becomes possible.
Closing Thought
We’re entering a phase where software creation is becoming less about mechanical execution and more about clarity of thought.
The winners won’t necessarily be the fastest typers or deepest framework experts.
They’ll be the ones who can:
- describe problems precisely
- break systems into understandable behaviors
- and guide AI tools effectively toward the right outcome
This stack — ChatGPT + Windsurf SWE-1.6 — has worked great for me when it comes to personal projects.
And it feels like this is only the beginning.