Build Your Own Features.
Development moves at the pace sales allow. If you don't want to wait, here's how to build any feature yourself — no programming knowledge needed.
On February 25, 2026, Andrej Karpathy posted something worth reading carefully.
Karpathy co-founded OpenAI. He built Tesla's Autopilot AI team. He is not someone who overstates things. And he wrote that programming has become unrecognizable. Not gradually, not in the usual "progress as usual" way — but specifically since December 2025, when AI coding agents crossed some threshold of coherence and started actually working. He described spinning up an agent, giving it a task in plain English that would have taken a full weekend three months earlier, and coming back thirty minutes later to find it done. He hadn't touched anything.
His conclusion: the era of typing code into an editor — the way things have worked since computers were invented — is over. You're now giving tasks in English and reviewing the results.
That shift is real. And it means something specific for you as a VoxelSite owner.
Take Your Future Into Your Own Hands
You have the full source code. PHP, clean architecture, no obfuscation, no encrypted files. Every feature you've wanted and waited for — you can now build yourself. Not by learning to program. By learning to direct.
This is that guide.
Why We're Not Building It Faster
Development moves at the pace sales allow. Every feature has a real cost: understanding how it fits the existing architecture, writing it, testing it across dozens of hosting environments, documenting it, and then maintaining it through every future update. Support tickets slow things further. Bugs always come first.
We're not holding features back. We're working through a list that grows faster than one person can clear it. For the full picture on how development priorities work, see Feature Requests & Pricing.
If you don't want to wait, you don't have to.
What Changed
Until recently, working with a codebase meant knowing the language. You had to understand PHP to extend PHP. You had to know CSS specificity rules to debug a broken layout. The source code was yours in theory but unreachable in practice unless you were a developer — or willing to pay one.
That is over.
Karpathy described his own experience: in November 2025 he was still 80% manual coding, 20% AI. By December it had flipped — 80% AI, 20% manual. Four weeks. He called it the biggest change to his coding workflow in two decades of programming.
What caused the flip: AI coding tools now read your entire codebase, understand how it fits together, and implement changes from plain English instructions. They run into errors and fix them. They test their own work. They explain what they're doing at each step. When something breaks, you describe what you see and they diagnose it.
You are not programming. You are directing. That distinction is what makes this possible for everyone now, not just developers.
The Tools
Cursor
The most widely used AI coding IDE right now. Built on top of VS Code, so the interface looks like a code editor — file tree on the left, editor in the middle, AI chat on the right. You open your project folder, describe what you want, and Cursor writes the code. It reads your entire codebase before answering, so it understands context. It is not guessing.
Windsurf
Cursor's closest competitor, built by Codeium. Same core concept: AI-native editor, full codebase awareness, chat interface for instructions. Some users find Windsurf's agent behavior more autonomous for longer multi-step tasks — it keeps going through problems with less prompting. Worth trying if Cursor doesn't feel right.
Google Antigravity
Google's agent-first IDE, announced in November 2025 alongside Gemini 3. Built on a fork of Windsurf, it takes the concept further.
What sets Antigravity apart is its Manager View: a control center where you run multiple agents in parallel across different tasks simultaneously. While Cursor handles one thing at a time in a chat panel, Antigravity lets you dispatch several agents to separate problems at once and monitor them from a single dashboard. For larger extension projects, that's a meaningful difference.
The Editor View works like a familiar VS Code-style interface with an agent sidebar. The Manager View is where things get interesting — agents autonomously plan their work, execute it across the editor, terminal, and browser, and produce Artifacts (screenshots, implementation plans, task logs) you can review and comment on directly, like commenting on a document. For frontend and visual work, Gemini 3 Pro produces particularly strong results here.
Claude Code
For the more confident user. Claude Code runs in your terminal and operates as a full autonomous agent — it reads files, writes files, runs commands, searches for solutions, and works through complex multi-step tasks without stopping to ask permission at every turn. It uses Claude, Anthropic's model — currently the strongest programming model available.
Less visual than Cursor or Windsurf, more capable for complex tasks. Boris Cherny, the engineer who built Claude Code, described it well: he catches himself starting to solve a problem the old way and has to remind himself — Claude can handle this. If you're comfortable opening a terminal, this tool is worth learning.
Claude Code Desktop and OpenAI Codex
For simpler, targeted tasks. Claude Code Desktop (from Anthropic) and OpenAI's Codex both offer lighter interfaces for when you know exactly what you want changed — replacing branding across the whole codebase, swapping colors, updating copy in bulk, changing configuration values — without navigating a full IDE.
What they cost
Most AI coding tools offer a free tier that's sufficient for getting started. Cursor's free plan includes a limited number of AI interactions per month. Paid plans start around $20/month. Claude Code requires a Claude Pro or Team subscription ($20+/month). Google Antigravity is currently free during its preview period. Pricing changes — check each tool's site for current plans.
Which AI Model to Use
The IDE is the interface. The model is the intelligence behind it. Most tools let you choose.
Claude (Anthropic) is the recommended model for VoxelSite extension work. It maintains coherence across large codebases, follows multi-step instructions accurately, recovers well when it hits errors, and writes clean readable code. When Karpathy talks about his workflow flip, he's largely talking about Claude.
GPT (OpenAI) is the second choice for programming. Capable, widely supported, good at explaining its reasoning step by step.
Gemini (Google) via Antigravity performs better on frontend and design tasks than pure backend programming. When you're working on visual changes — layout, spacing, color, component design — Gemini often produces stronger results than the others. For PHP logic and backend work, Claude or OpenAI is the better choice.
When in doubt: Claude for programming, Gemini for design.
Getting Started
Step 1. Extract the source code
If you purchased from CodeCanyon, you have a ZIP. Extract it. You now have a folder with the complete VoxelSite codebase — every file, readable, yours.
If you haven't installed VoxelSite on a server yet, follow the Installation guide first — you'll need PHP hosting to actually run it. See Requirements for what works. Once it's running on your server, you can also open the same files in an AI IDE to extend them.
Step 2. Install an AI IDE
We'll use Cursor for this walkthrough, but the same process works in Windsurf, Antigravity, or any AI IDE described above.
Download from cursor.com and install it. Open Cursor. Then: File → Open Folder → select your VoxelSite directory.
You'll see the file tree on the left. Every folder and file in the project. You don't need to understand what any of it does yet. The AI does.
Step 3. Open the chat panel
In Cursor the AI chat lives on the right side. This is where you work. Think of it as messaging a developer who has read every file in your project and is waiting for your next instruction.
You type what you want. It reads, thinks, and writes code. You review. You say what to change. It changes it.
That's the loop.
The Prompts That Work
This is the most important part of the guide. The quality of your instructions determines the quality of the output. These are tested patterns, not suggestions.
Always start here
Before asking for anything, orient the AI to your specific codebase. Paste this first, every single time you open a new session:
Read the full codebase. Understand the tech stack, the file structure,
and how the components connect to each other. Give me a summary of
what you found: the main folders, what each does, and how a page gets
generated from a user prompt to a published file. Confirm when you're
ready to work.
Wait for the response. Read it. If anything sounds wrong, correct it before going further. An AI that misunderstands the architecture makes confident mistakes. This step costs two minutes and prevents most problems.
Planning a new feature
Never ask for code first. Ask for a plan.
I want to add [describe the feature in plain language].
Before writing any code, explain how you would implement this given
the existing architecture. Which files would you touch? What are the
risks? What edge cases should I know about? What approach would you
recommend?
Read the plan. If it sounds reasonable and doesn't involve touching files you weren't expecting, say:
That approach looks right. Implement it step by step. After each
significant step, tell me what you did, what you changed,
and what comes next.
The step-by-step instruction matters. It keeps the AI from making ten changes at once and leaving you unable to track what happened.
A real example
You want to add a cookie consent banner — one that sets a cookie when accepted and hides itself on return visits.
Start with the plan prompt above. The AI will tell you it needs to add a small JavaScript snippet to the base template, a CSS component for the banner styling, and a check on page load that reads the cookie and skips the banner if it's already been set. It will identify the specific template file that wraps all pages.
Review that plan. If it sounds right, approve it. The AI implements one piece, reports back, moves to the next. When it's done you have a working feature — and you understand roughly how it was built because you followed each step.
Fixing something broken
[Describe what's broken]. Here's what I see: [paste the error message
or describe the visual problem exactly].
Read the relevant files and diagnose the issue before making any
changes. Tell me what you think is wrong and why.
Review the diagnosis. If it sounds right:
That makes sense. Fix it. Don't touch anything outside the files
directly involved in this issue.
That last sentence is not optional. Without it, AI tools sometimes "improve" things you didn't ask about and introduce new problems while solving the original one.
Making visual changes
For quick visual tweaks, VoxelSite's built-in Visual Editor lets you click-and-edit elements directly in the preview — no external IDE needed. The approach below is for deeper structural changes or modifications to the source code itself.
I want to change [describe the visual element — be specific: which page,
which section, what it looks like now, what you want instead].
Keep changes isolated to the relevant CSS and template files.
Do not modify any PHP logic. Show me exactly what you plan
to change before applying it.
Specific beats vague every time. "Make the header look better" produces worse results than "make the header background dark navy, increase the logo size by 20%, and add a 1px white border at the bottom."
Replacing branding across the whole codebase
Find every instance of [old brand name / color value / logo filename]
across all files. List every occurrence with the file name and line
number. Do not change anything yet.
Review the list. Confirm it looks complete. Then:
Replace all of those with [new value]. List every file you
modified when done.
Find first. Change second. Always two steps for wide-reaching changes.
Understanding something before touching it
Explain how [specific feature or behavior] works in this codebase.
Trace it from the user action all the way through to the output file.
Do not change anything.
Use this whenever you're unsure. Understanding before acting is the difference between a clean change and an afternoon of debugging.
After every change, verify
What did you change, exactly? List every file modified and describe
what changed in each one. Did you introduce any new dependencies?
What should I test before considering this done?
Make this a habit. It takes thirty seconds and gives you confidence the change is complete and contained.
Working With AI Agents Well
The tools work. They work best when you direct them clearly.
One thing at a time. Five changes in one message produces worse results than five separate sessions. Finish one change, verify it, then move to the next.
Scope every instruction. Phrases like "don't touch files outside of X" and "don't modify any PHP logic" are your guardrails. Use them. An AI with unlimited scope will sometimes wander into territory you didn't intend.
Read the plan before approving. Every capable AI tool will explain its approach before writing code. Read it. If the plan touches files you weren't expecting, ask why before approving. Correcting a misunderstanding takes ten seconds. Undoing a wrong implementation takes longer.
Keep a backup. Before any significant change, copy your working folder somewhere safe. VoxelSite's built-in Snapshot feature saves your current Studio state — use it before any session where you're trying something new.
Know what updates touch. When VoxelSite releases a new version, it updates the Studio engine but preserves your published pages, settings, images, and data. Changes you make to the generated website files — the pages your visitors see — survive every update. Changes to Studio internals (like custom system prompts) use a separate override system that also survives updates.
Test locally first. Make changes to a local copy of your files. Verify they work. Then upload to your live server. Never experiment on production.
When it goes wrong, be specific. "That broke the mobile navigation. On screens under 768px the menu doesn't open when I tap the hamburger icon. Revert only that change and try a different approach." The more precisely you describe the problem, the faster it gets resolved.
Push back when the plan seems off. If the AI proposes modifying ten files for something that should touch two, ask it to explain why. Sometimes the scope is necessary. Sometimes it's overcomplicating. You don't need to understand code to have good instincts about whether a change feels too large.
What You Can Realistically Build
Non-developers using AI coding tools are shipping things that required freelancers six months ago. Here's an honest breakdown.
Straightforward — do it today. Color and font changes, layout adjustments, new static pages, updated form fields, revised email templates, logo replacement, adding analytics or tracking scripts, cookie consent notices, footer changes, SEO metadata updates.
Some of these — like SEO updates, form fields, email settings, and design changes — can be done directly inside VoxelSite Studio without an external AI IDE. See the Chat, Visual Editor, and Code Editor documentation. The AI IDE approach is for changes that go beyond what the Studio offers.
Achievable with a few sessions. New page sections, interactive components (FAQ accordion, image gallery, before/after slider, testimonial carousel), connecting a different AI provider, adding a second language to the interface, custom changes to the Studio dashboard.
More involved but possible. New admin pages in Studio, custom content types, integrations with external services like booking calendars or newsletter platforms, changes to how the AI generates pages via System Prompts, custom publishing workflows.
Worth hiring a developer for. Anything requiring real-time data, complex user authentication, payment processing, or structural changes to VoxelSite's core generation engine. Knowing where this line sits saves frustration. Working within it produces good results.
A Note on the VoxelSite Codebase
VoxelSite is PHP with SQLite. No heavy frameworks. No build step. No node_modules. No Composer dependencies in the generated output.
This matters because it makes the AI's job easier and your results more predictable. There are no layers of abstraction stacked on top of each other. The logic is linear and readable. An AI scanning this codebase finds clear patterns and follows them. You'll get cleaner results here than you would working on a complex React or Laravel project. For a full breakdown of the architecture, see Tech Stack. For the generated file structure, see The AI Engine. For how colors and typography are managed, see the Design System.
One distinction worth keeping clear: the Studio (_studio/) is separate from the published site. Changes to Studio files affect the builder interface — what you see when you're editing. Changes to the output files affect what your visitors see. When giving instructions, be explicit about which side you're working on. "Change the header in the Studio interface" and "change the header on the published site" are different tasks. If you want to customize the Studio interface itself, see Customizing the Studio — it includes the full source, build tools, and module map.
VoxelSite Studio also includes a built-in Code Editor powered by Monaco (the same engine behind VS Code), with an AI-powered inline editing feature — press Cmd+K on any code block to describe a change in plain language. For many smaller modifications, you may not need an external AI IDE at all.
The Timing
A year ago, extending a codebase without programming knowledge meant hiring someone or going without. The tools didn't exist at the quality needed. Today they do.
The models are capable. The interfaces are approachable. The barrier left is your willingness to start.
Your source code is already on your computer. The feature you've been waiting on might be an afternoon away. Start with something small — ask the AI to explain one part of the codebase you're curious about. Make one small change. See what happens.
The leverage is real. Pick it up.