Lock the scope before the green light
A weekend project usually fails in the planning, not in the typing. Before you open Codex, decide what a finished version looks like on Sunday evening: one user, one workflow, one clear output. Write that outcome as a single sentence and keep it at the top of your notes so every prompt you send points at the same target.
Draw a hard boundary around what you will not build. Authentication, billing, deployment pipelines and admin dashboards are classic traps that consume an entire weekend one small decision at a time. A side project earns its keep by proving that one idea works end to end, not by being complete in every direction.
Give the project a testable shape before the first prompt. Scaffolding makes every later request cheaper, because the model always has something concrete to improve instead of a blank folder and a hopeful description. It also gives you a way to check the work without trusting the answer.
- A single entry point that produces the main artifact, whether that is a script, a report, a feed summary or a small web view.
- A sample input file you can paste into a prompt whenever you need to reset context or reproduce a bug.
- A short change log that records what Codex changed and why, so you can revert without digging through commit history.
- A definition of done you can check in under a minute, such as a command that runs and prints one expected line.
Treat this list as the contract for the weekend. When a request drifts outside it, the answer is a note for the next lap, not a new feature branch on Saturday night.
Match the model to the task in front of you
Codex works with any OpenAI-compatible endpoint, so the model behind it is a design choice rather than a fixed decision. Current good practice is to route work by task instead of choosing one model for everything and hoping. Boilerplate, renames and mechanical edits do not need your strongest option, while the shape of a tricky data flow deserves careful attention.
A sensible split is an economical model for the mechanical passes and a stronger one for the decisions that are expensive to reverse. For a weekend build, Claude Haiku 4.5 handles scaffolding and quick experiments well, while GPT-6.1 Sol is a good partner for the architecture you would otherwise stall on.
Keep a small note of which model handled which change. That record tells you whether a rough edge came from the model, the prompt or the design of the code, and it stops you from rerunning the same request with a different name attached and expecting different luck.
Switch models only between tasks, never in the middle of one. Continuity is what lets you compare results, and comparison is the only honest way to decide where each model belongs in your own workflow. Nothing here requires a long setup either, because the split you choose on Friday can change on Saturday.
Point Codex at a pay-as-you-go relay
The setup step most side projects skip is deciding where the tokens come from. A pay-as-you-go relay keeps a weekend experiment honest: you pay for what you actually use, per token, with no commitment beyond the run you are in. SwiftRelay is built for exactly this pattern and works with Claude Code, Codex, Gemini CLI and any OpenAI-compatible SDK.
Configuration is short. The API host is https://api.fastapirelay.com; Claude Code and Gemini CLI take the bare host, while OpenAI-compatible SDKs add /v1 to the end of it. Put the base URL and one key in an environment file, keep that file out of version control, and every tool in your stack can share the same account.
Sign up for SwiftRelay and your new account starts with a small gift credit, which is enough to get the first run moving, and inviting friends earns 14% of their top-ups. That fits the way weekends actually work: bursts of heavy use while you build, then quiet days between ideas.
Check usage at the end of each session, before you walk away from the keyboard. It takes a minute, it keeps surprises out of the following week, and it tells you which part of the project is genuinely expensive so you can spend your attention there.
Keep the key separate from the repository and rotate it when the project grows past one machine. Credential hygiene is boring during a weekend rush and very hard to retrofit afterwards.
Run the build in small, reviewable laps
Once the tooling is in place, the quality of the weekend depends on prompt discipline. The most reliable pattern is one task per request, written as a short brief: what exists now, what should change, what must not change, and how you will tell that it worked.
- Ask for a plan before code on anything that touches more than one file, then approve or amend the plan and let the implementation follow it.
- State constraints in the prompt itself, such as the language version, the framework you are already using and the files that are off limits.
- Request tests alongside the change rather than afterwards, so the next request has a target to keep green.
- Ask Codex to explain its reasoning briefly when a change surprises you, then judge the explanation against the code rather than accepting it on trust.
Review every diff before you accept it. Read the code as you would read a stranger's pull request: does it do what the prompt asked, does it add anything you did not ask for, and does it leave the entry point working?
Run the project after each accepted lap, not at the end of the day. Small checkpoints make failures legible, and a legible failure is a prompt you can write in a minute instead of a debugging session that eats the evening.
When Codex produces something nearly right, resist the urge to accept it and patch by hand later. Send the correction back as a new prompt so the next change sits on top of a clean state, and the change log keeps a straight line.
Close the weekend with a shippable cut and a next checklist
Sunday afternoon is for cutting, not expanding. Freeze the feature list, run the definition of done one last time, and package the smallest thing someone else could try: a README with one command, one sample input and one screenshot of the output.
- The entry point runs from a clean clone with the environment file filled in.
- The sample input produces the expected output without manual editing.
- The change log lists every request that moved the project, in order.
- The notes capture the three ideas you deliberately left out.
Then write the first prompt for the next lap while the context is still warm. A weekend project keeps its value as a repeatable ritual: scope on Friday night, build on Saturday, ship on Sunday. Do it twice and you have a habit, not a one-off.
That ritual is the real deliverable. The artifact may be small, but the practice of turning a vague idea into something running, with a model you chose on purpose and billing that matches your actual use, compounds every time you come back to it.