FAQ: A Free Allowance Is Not Your Capacity Plan

Developers keep pasting a free-model claim into merge requests.
They call that pasted line a new capacity plan.
I ask which file the pipeline will still archive.

What are people repeating this week?

AI launch threads are loud on DEV again.
A green chat is getting treated like a finished job.

I keep seeing the same shortcut in review comments.
The shortcut sounds thrifty, and it is also sloppy.

Is a launch headline the same thing as a quota?
No, a headline is not a limit you can audit.

Does a free checkbox reserve capacity for your team?
No, a checkbox does not reserve a machine for you.

Why this FAQ exists

I care more about job logs than about chat scrolls.
I want a corrected model before the next free sprint.

This draft is not a lab report from a private bench.
The commands below are a proposal I have not executed here.

Myth one: a remembered grant is a budget

Developers repeat a token number from a screenshot.
They plan next month as if that number were a contract.

I will not reprint a token ceiling in this post.
No current limit page was attached to this brief.

Here is the operator note, kept narrow on purpose.
MonkeyCode free model access and a free server option are operator-supplied claims here.
Disclosure: This article was prepared as part of MonkeyCode's product outreach.

What should you trust when the number matters?
Trust the limit page you open on the day you spend.

Trust the error text you hit when the pool is empty.
Do not trust a paraphrase that I froze into Markdown.

Corrected model for the allowance

A free allowance is a rehearsal budget with an unknown edge.
It is not an invoice line your finance team can book.
It is not a promise that tomorrow's pool matches today's pool.

Myth two: free server time is reserved capacity

A free server option is not a reserved machine with your name on it.
Neighbors can change, and the disk can vanish after the session.
I would not park a release binary on that disk overnight.

Does the option page promise a hostname you can pin?
If it does not, you do not have reserved capacity.
You have a scratch seat for one public rehearsal.

Postcard commands, not a reservation

# This block is a proposal you should run on that seat.
printf 'host=%s\n' "$(hostname)"
printf 'user=%s\n' "$(id -un)"
printf 'date=%s\n' "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
git rev-parse HEAD
git status --porcelain=v1

Read those five lines as a postcard from one seat.
A postcard does not reserve that seat for tomorrow's job.
If the hostname changes, your capacity plan was only a hope.

Myth three: a green answer is a green job

The model can print a cheerful line that says the job passed.
Your GitLab job can still fail after that cheerful line.
Which of those two texts do you actually archive?

I archive the job log and the artifact checksums.
I do not archive a compliment from a free model session.
A compliment has no job id, and it has no trace URL.

A note job, labeled as a note

# This snippet is a proposal, not a live project config.
rehearsal_note:
  stage: test
  script:
    - python3 scripts/ledger.py < note.json > verdict.txt
    - test -s verdict.txt
  artifacts:
    paths:
      - note.json
      - verdict.txt
    expire_in: 7 days

The artifact is a note with a short expiry.
A note is not a release binary in your package registry.
Expiry is a feature here, not a storage strategy.

Myth four: the model read the repo, so it knows CI

People paste a README and call that a pipeline review.
The model saw the text you pasted, not the include graph.
It did not fetch remote templates, and it did not run the job.

Did the session resolve every include you actually use?
If you cannot show the resolved YAML, the review is incomplete.
A fluent summary of the README is not a resolved pipeline.

# This command only inspects the file you already have on disk.
test -f .gitlab-ci.yml
grep -n 'include:' .gitlab-ci.yml || echo 'no local include key'

That grep only shows a local include key.
It does not fetch remote templates, and it does not lint the graph.
Treat a missing include line as a clue, not as proof.

Myth five: zero price means zero drift

Free tiers move while your YAML sits still in git.
Model names change, and server neighbors change too.
Your pipeline file does not receive that memo by itself.

So what do you pin when the vendor page can move?
Pin the git SHA you rehearsed, and pin the command list.

Pin the artifact hashes you actually downloaded after the run.
Do not pin a memory of a marketing sentence from last month.

The three-column ledger

I want a ledger with three columns in the repo.
Column one lists what the free path may attempt.

Column two lists what the free path must not touch.
Column three lists what the real job must still emit.

Question	Free path may	Real job must still show
May it draft a test?	Yes, as reviewable text	The test file at a recorded SHA
May it compile public code?	Yes, on disposable input	Log URL plus a real exit code
May it see CI secrets?	No, not even once	Masked use only inside the job
May it store a release binary?	No, scratch disks expire	Registry checksum and package name
May it approve the merge?	No, it can only comment	Human review plus a green pipeline

That table is the corrected mental model for this desk.
The free path drafts text and rehearses public steps.
The real job proves the result and stores the evidence.

Run this classifier before you argue

This script is a proposal, not a result from my machine.
It reads a JSON note and prints one verdict line.
It does not call a network, and it does not know your quota.

#!/usr/bin/env python3
"""This proposal classifies a rehearsal note and was not executed."""
import json
import sys

REQUIRED = ("git_sha", "commands", "exit_code", "artifact_sha256")
FORBIDDEN_HITS = ("CI_JOB_TOKEN", "DEPLOY_KEY", "BEGIN OPENSSH PRIVATE")

def main() -> int:
    note = json.load(sys.stdin)
    missing = [key for key in REQUIRED if key not in note]
    blob = json.dumps(note)
    leaked = [item for item in FORBIDDEN_HITS if item in blob]
    if leaked:
        print("verdict=reject reason=secret_marker")
        return 2
    if missing:
        print("verdict=rehearsal_only missing=" + ",".join(missing))
        return 0
    if note.get("exit_code") != 0:
        print("verdict=failed_evidence")
        return 1
    print("verdict=evidence_candidate")
    return 0

if __name__ == "__main__":
    raise SystemExit(main())

Feed the script a short stub and read the line.
You should see a rehearsal verdict, not an evidence verdict.

printf '%s\n' '{"git_sha":"abc123","commands":["go test ./..."]}' \
  | python3 scripts/ledger.py

The expected text is a rehearsal verdict with two missing keys.
I did not run that pipe while writing this article.
Run it on your laptop before you trust the expected line.

If your Python is older than 3.9, adjust the typing line.
The logic itself is only a local JSON classification.
It cannot see GitLab, and it cannot see a vendor quota.

A ten-minute review ritual

I use a short ritual before I trust a free rehearsal.
None of these steps requires a secret in the prompt.

1. Open the limit page and paste the URL into the MR.
2. Record the git SHA before you ask the model anything.
3. Run the postcard commands and save the five lines.
4. Draft the test text in the free session, then stop.
5. Run the real job on the runner your team already trusts.
6. Feed the JSON note to the classifier and read the verdict.
7. Archive the job log next to the ledger, not the chat.

Where the free path still helps

I might paste the ledger rules into a free model session.
I might ask that session to draft a JSON stub for the script.
I might use a free server to compile a public sample once.

I am not publishing a speedup, a model name, or a hardware shape.
Those facts were not in the sources attached to this draft.
If a vendor page states them today, quote that page in the MR.

One ask, and then I will stop selling the idea.
If you already have that free model access, save the ledger JSON.
Keep it beside the job log, not instead of the job log.

Who should skip this

Skip this approach if you need a signed release today.
Skip it if the repository holds production secrets or customer data.
Skip it if policy forbids any third-party compute for that repo.

Skip it if you need a written quota or a GPU shape.
Skip it if you also need a dated expiry in writing.

I do not have those limits written in this brief.
I will not invent them so the ending sounds more confident.

What this FAQ will not freeze

I will not name a model string from memory in public.
I will not print a token ceiling as if I had measured it.
I will not describe duration or permanence from a slogan.

Those claims belong on a current primary page, not here.
Open that page on the day you spend the allowance.

Quote the page in the merge request if the number matters.
A DEV article is a poor place to freeze a moving limit.

One question for the reviewer

What did your last free session actually leave on disk?
If the answer is only a chat scroll, you rehearsed a draft.
You did not ship a job, and you did not store evidence.

Keep the table in the repo next to the script.
Keep the job log next to both files after every real run.
Then the free path can stay useful without pretending to be capacity.