Building a Vocabulary App in Half a Day: A Hands-On Guide to AI Project Workspaces
A step-by-step walkthrough of using an AI coding workspace's "project" feature to take a vocabulary app from a one-line idea to a working mini-program in half a day—covering prototyping, structured data preparation, code generation, deployment, and reusable workflow lessons.
Building a Vocabulary App in Half a Day: A Hands-On Guide to AI Project Workspaces
Introduction: From a One-Line Requirement to a Shippable Product
The story started simply: a friend preparing for a language exam abroad needed to memorize a large volume of vocabulary. Existing vocabulary tools on the market were either bloated with features or didn’t fit her review rhythm, so the idea of “building a vocabulary app for myself” was born.
In the past, building a personal tool like this would take at least a few weeks: sketching prototypes, sourcing word lists, writing front-end and back-end code, configuring environments, debugging, and publishing. This time, I used the “project” capability of an AI coding workspace to organize the entire development process—and ended up with a working prototype from concept to deployment in half a day. The product isn’t polished, but the “does it exist” question was solved first; the rest is just iteration.
This article doesn’t discuss any specific product. Instead, it abstracts this experience into a reusable methodology: how to use a “project”—a structured workspace—to connect five stages: prototyping, data, code, deployment, and archiving, so that AI becomes a genuine collaborator rather than a one-off Q&A machine.
Why a “Project” Instead of a “Chat”
Many developers use AI by opening a chat window, pasting in a requirement, getting some code, then opening a new window for the next task. This approach has three obvious weaknesses:
- Broken context: Every conversation is an isolated island. The AI doesn’t know the tech stack decisions, color schemes, or data structures you settled on earlier.
- Assets don’t accumulate: Reference materials, documents, and images are scattered everywhere and can’t be reused by later tasks.
- Collaboration is hard: Task assignment, progress syncing, and handoffs all rely on manual coordination.
The core idea of “project” mode is to bring “people, assets, tasks, and rhythm” into a single workspace, typically with these capabilities:
- Assets and configuration: Documents, reference images, and word list files go into the project’s asset area. The AI automatically reads them when executing any task, so you never re-explain the background. Frequently used prompt templates and tool connectors can also be mounted at the project level.
- Planning board: Create to-dos in natural language—for example, “assign word list cleanup to A and UI review to B.” The board gives an at-a-glance view, with comments and reminders on progress changes.
- Task collaboration: Multiple people can join the same task session and make changes together. If a task is half-done and someone needs to take over, it can be handed off wholesale, with context and intermediate results passed along intact.
- Scheduled tasks: Repetitive work like daily report summaries or periodic data pulls runs automatically once rules are configured.
With this workspace as the foundation, you never have to re-establish context from scratch in later steps—this is the key prerequisite for getting things done in half a day.
Start with a Prototype: Borrow from Proven Products Rather Than Invent from Scratch
Before writing any code, decide what it should look like. This avoids 80% of rework. My approach:
- Collect references: Pick a few well-reviewed apps of the same type and capture their core pages—home, flashcard review, study statistics, and profile pages.
- Define constraints: Tell the AI the design constraints—for example, a blue-based color scheme, and the home screen must include three core entries: “New Words Today / To Review / Mastered.”
- Generate a high-fidelity prototype: Have the AI follow the layout language of the reference screenshots to produce a set of clickable, high-fidelity pages.
The takeaway of this step comes down to one sentence: use the skin of proven products, build your own skeleton. Don’t let the AI invent interactions out of thin air—give it references, constraints, and veto rules. This minimizes communication overhead and keeps direction from drifting. The resulting prototype also becomes the visual reference for later code generation, killing two birds with one stone.
Data Preparation: Turning Word Lists from Unstructured to Structured
The core asset of a vocabulary app is the word list. Word lists found through public channels are mostly PDFs or web pages that a program can’t consume directly—they need to be converted into structured data.
The general workflow:
- Get the raw material: Find the vocabulary PDF for the target exam and put it into the project’s asset area.
- Extract and clean: Have the AI parse the document, strip headers, footers, and example-sentence formatting noise, and extract fields like “word, phonetic transcription, part of speech, definition, example sentence.”
- Output structured data: Convert everything to JSON so the front end can load it directly:
[{"word": "abandon","phonetic": "/əˈbændən/","pos": "v.","meaning": "to give up; abandon","example": "They had to abandon the plan.","familiarity": 0}]
- Spot-check: Randomly sample a few dozen entries and verify them manually. Only import the full dataset after confirming the fields are complete and definitions are correct.
One lesson here: don’t aim for a perfect one-shot conversion. First run the parsing rules on a small batch of samples, confirm the field mapping is correct, then scale up to the full dataset. This saves a lot of rework time.
Code Generation: With Prototype and Data Ready, Let the AI Write the Implementation
Once the visual prototype and data structure are fixed, the quality of generated code is largely assured—the AI is no longer guessing, but implementing within clear boundaries. The recommended approach is to break the work down by module:
- Page skeleton: Generate the structure and styling of each page based on the prototype, prioritizing visual fidelity.
- Review logic: Implement the core memory scheduling. A minimal viable review algorithm can be based on a simplified spaced-repetition model:
// Simplified review scheduler: correct answers raise familiarity, wrong answers reset itfunction updateFamiliarity(word, isCorrect) {if (isCorrect) {word.familiarity = Math.min(word.familiarity + 1, 5);} else {word.familiarity = 0;}// Higher familiarity means a longer interval before the next reviewconst intervals = [0, 1, 2, 4, 7, 15]; // unit: daysword.nextReview = Date.now() + intervals[word.familiarity] * 86400000;return word;}
- Data persistence: Connect the word list JSON with the user’s study progress (typically stored in local cache or a cloud database).
- Finishing touches: Have the AI generate surrounding assets like the app icon and splash screen as well.
Preview and verify immediately after each module is done, and solve problems locally—don’t let small errors pile up into big integration headaches.
Integration, Deployment, and Archiving
Run it in the dev environment: Import the generated code package into the mini-program developer tool and focus on verifying three things—whether page navigation matches the prototype, whether the study flow is closed-loop (new words → learn → review → statistics), and whether data persists. When issues appear, describe the symptoms in the project session and let the AI locate and fix them. Since all the code and design conventions are already in context, fixes are far more efficient than re-describing everything from scratch.
Publish: Submit for review following the platform’s standard process. Simple personal tools usually face little friction in review.
Archive the results: Deployment isn’t the end. Archive the final prototype, the word list JSON, the code repository URL, and lessons learned into the project’s asset library. This has two payoffs: first, during later iterations the AI can read historical conventions directly; second, when a similar need arises—say, a different exam’s vocabulary edition—the entire workflow can be reused almost as-is, driving development cost close to zero.
Key Takeaways
- Set up a structured workspace before doing the work: Asset management, planning boards, and collaboration mechanisms are the foundation of effective AI collaboration.
- Use references and constraints instead of open-ended generation: Give the prototype reference images, give the data samples, give the code interface conventions. The AI’s output quality is proportional to the certainty of its input.
- Move in small steps, verify module by module: Each stage should produce a verifiable intermediate artifact—don’t let uncertainty propagate downstream.
- Treat the workflow itself as an asset: What’s truly valuable isn’t this one vocabulary app, but the reusable pipeline of “idea → prototype → data → code → deployment.”
As AI coding tools evolve from “chat boxes” into “project spaces,” the barrier for individual developers to build complete products has dropped dramatically. Shipping a vocabulary app in half a day is just the beginning—the same approach applies to most small, focused tool products.
