Product demo · a real feature on a real codebase
forge SaaS takes on a 2017 Gitea feature request: confidential issues
Gitea's users have asked for confidential issues since 2017. Here forge SaaS implements that request on Gitea's own code (our public fork), stage by stage, while a product team approves each stage. In this demo, our team plays the roles of the fictional Northwind Product Co. forge's own review failed the first pass on a real leak it found in its own work. forge patched the leak at handover, a follow-up job hardened the fix and added tests, and the follow-up's review passed. The result is a tested pull request, for 124.35 forge tokens (1 forge token = $1) and 34 minutes of the team's review.
Gitea is MIT-licensed open-source software by the Gitea Authors. No endorsement by the Gitea project is implied.
What this run returned
One run on one codebase, priced conservatively: the low end of the estimate, review time counted as cost; $20/h is only an example. The review counted is the gate reviews; your own review of the pull request is not included, and the estimate includes code review, release and documentation hours (22 h at the low end) that your team may still spend. Use your own rate →
About 7 minutes, with narration; captions are on (CC button to turn them off). It opens with this run's result and how to read the return, and closes with what the run returned. One real run on forge SaaS (a job, and a follow-up job started from its review's blocking items), filmed on 3 Nov 2026, not re-staged or re-run. This film is a shortened cut: agent work is fast-forwarded and gate reviews are shortened, both labelled on screen. The whole run, start to pull request, is under Check it yourself as a one-minute time-lapse. Northwind Product Co is a fictional company and its people are demo personas: at each gate our team made the decision, and a script carried it out in that persona's name. At two decision steps (the questions and the architecture gate) the script's first browser attempt failed and it tried again; each decision was made once, and the film shows the attempt that went through.
Jump to
The problem: Gitea #3217, open since 2017
On a public Gitea repository every issue is public. Some issues must not be: a security report before the fix ships, or a bug report whose logs hold customer data. Teams work around it with a second, private repository or with e-mail, and then cannot simply publish the issue on disclosure day.
Gitea is a self-hosted Git service that companies run for their own code.
Labelled confirmed by the maintainers. Two community attempts were closed without merging; forge was told not to look at or reuse them, and did not read them (checked in both jobs' records and all agent transcripts). It worked from the request and today's code. Counted on 3 Nov 2026: go-gitea/gitea#3217.
What the team asked for
Northwind's security lead, a demo persona played by our team, typed the requirement into a new forge SaaS job, pointed it at our fork of Gitea, and listed what "done" means:
A Confidential option
When creating or editing an issue, and in the REST API. Each change shows in the issue's timeline; existing issues stay public.
The right people see it
The author, assignees, repository writers and admins, and site administrators. Everyone else gets the same "not found" as for a missing issue. (Whether writers see it was left open in the request and settled in the questions.)
No leaks anywhere
Lists and counts, search, the API, feeds, RSS, notifications and e-mails, cross-references, attachments, milestones and project boards.
Also asked for: unit tests for every role, SQLite integration tests for every place an issue could leak, and a Playwright browser test. Out of scope: confidential pull requests, per-issue invite lists, security advisories, and hiding that an issue number exists.
How forge ran it, stage by stage
forge works the way a careful team would. At each gate the stage waits until the person who owns it in Northwind decides: approve, or send it back with written feedback. 7 gates in all, six before any code and one in the follow-up job, plus the questions: 2 approved first time, and five sent back once each and approved on the second round.
-
Discovery agents
Read the Gitea codebase at the pinned baseline, mapped how issues are stored, listed and searched, and ran the project's tests on the untouched code (Gitea's backend unit tests, make test-backend: 235 of 240 Go packages passed, 5 skipped), so a later failure can be told apart from one that was already there.
-
Questions and the requirement questions · security lead; gate · analyst
Asked the security lead five open points, each with options and a recommended answer: who may see a confidential issue, who may change the setting, webhooks and Actions, what a public issue that references a confidential one shows, and how counts behave.
The security lead answered: writers and above see it; the author sets it only when filing, writers change it any time; no webhooks or Actions for it; a public reference shows only "referenced a confidential issue"; counts are per viewer. Two of the five answers went against forge's recommendation. The analyst approved the requirement first time. -
Project brief gate · analyst
The settled scope, the roles and the risks, in one brief.
The analyst approved the brief first time. -
Requirements (PRD) and the estimate gate · product manager
Wrote the product requirements and, before any design or code, an estimate of what a conventional team that knows the codebase would need: hours by role, low, likely and high.
Sent back once: keep every requirement, the permission rules and the estimate, but drop three targets this build could not check (SQLite only, 2 CPUs): the latency target for 10,000 issues, migration tests on MySQL, PostgreSQL and MSSQL (the migration is written for all of them, tested on SQLite), and per-test time limits. Approved on the second round, with the estimate of 198 to 428 hours (likely 290). -
Architecture gate · architect
Where the visibility rule lives, and how every listing, search, feed and notification path applies it.
Sent back once, design accepted:make test-backendalone never runs the integration or browser tests, so the test command became Gitea's backend unit tests, the SQLite integration tests for confidential issues plus the 97 existing ones for the areas touched, the v29 migration test, and one Playwright journey in Chromium; and run the existing integration and migration tests once on the untouched code (they passed). Approved on the second round. -
Low-level design gate · architect
Changes file by file, the database migration, and the API fields.
Sent back once: the REST API's count of open issues on a repository must be per viewer, with the same rule as the Issues tab, so a count never gives away a hidden issue; and the tests must cover it. Approved on the second round. -
UI design gate · designer
Mock-ups of the Confidential option and marker, in Gitea's own look, at desktop and phone width.
Sent back once: keep the new warning label, the dialogs, the help text and the labels for screen readers, but revert three style changes that would have changed every form and checkbox in Gitea. Approved on the second round. -
Stories, development and tests agents
Split the work into 16 stories, built each one with its tests, and ran the agreed test command and the project's checks after development. The first run failed (the test command and four checks); forge's fix loop repaired it on its first attempt, and the tests and all 18 checks then passed.
-
UI review agents
Opened the changed pages in Chromium as seven roles, each page as the roles that matter for it, at desktop and phone width (170 screenshots of 85 page and role pairs), and fixed one piece of truncated text. It also saw a leak in the dependency rows of an issue's timeline, and recorded it as not fixed.
-
Review stage and handover: FAIL agents
forge's own review stage, a separate review agent run apart from the build, failed the work with five blocking items. One was a real security leak: a viewer who may not see a confidential issue could still read its title and link in the dependency rows of another issue's timeline, on the web and in the API. The others were two project checks broken by what the UI review left behind: a template fix it had not staged, and scratch data in the repository. After the verdict, the handover stage patched the comment filter so those rows are dropped on the web and in the API, with a unit test, and staged the template fix; the scratch data was gone by then. No review checked that patch, so the verdict stayed FAIL. forge pushed the branch, with the patch in its first commit, and opened the pull request with that verdict in its description.
-
Follow-up job: the change plan gate · architect
One click on "Fix blocking issues" started a follow-up job, with a requirement forge drafted from the review's blocking items, on the same branch.
Sent back once: make the API guard mandatory, not optional, with an integration-test assertion; and the pushed branch must hold the staged fixes, with every check the review ran passing again. Approved on the second round. -
Follow-up build and review: PASS agents
Found the handover's filter patch and template fix in place, and no scratch data left. Made the API converter's guard mandatory, as defence in depth, so the API never returns a hidden dependency even if a caller skips the filter; added a unit test and an integration-test assertion; and re-ran the 6 checks. Its review was the first to pass with the fix in place: 0 blocking items, and 0 of 6 project checks failing. forge pushed a second commit to the same pull request, 32 minutes after the follow-up started, for 3.15 forge tokens. A person still reviews and merges it, as with any colleague's pull request.
Why the FAIL is in the film
forge's review is there to block work that is not ready, including forge's own. Here it found a leak the build had left in (the UI review had seen it but not fixed it) and refused to pass the work. forge's handover then patched the leak, but no review had checked that patch, so the verdict stayed FAIL. A 32-minute follow-up, with the architect deciding the plan, made the API guard mandatory, added tests, and was the first review to pass. That is the review doing its job, so we show it rather than cut it.
What went wrong, and how it was fixed: The first test run after development failed (the agreed test command and four project checks), and forge's fix loop repaired it on its first attempt. forge's own review then failed the work: a real leak (a viewer who may not see a confidential issue still saw its title and link in the dependency rows of another issue's timeline, on the web and in the API) and two checks broken by what the UI review left behind (a template fix it had not staged, and scratch data in the repository). forge's handover stage then patched the leak on the web and in the API and committed the template fix (the scratch data was already gone), but no review checked that patch, so the verdict stayed FAIL. A follow-up job that forge drafted from those blocking items made the API guard mandatory as defence in depth, added tests and re-ran the 6 checks, for 3.15 forge tokens in 32 minutes; its review was the first to pass with the fix in place.
What was delivered
Tests, counted the way Go reports them, in test packages. Before the change, on the baseline: 235 of 240 backend packages passing, 5 skipped. After the build, the agreed test command (scope set by the architect at the architecture gate: Gitea's backend unit tests, the SQLite integration tests for confidential issues plus the 97 existing ones for the areas touched, the v29 migration test, and one Playwright journey in Chromium) passed 237 of 242 packages (242 adds the integration and migration packages to the 240), 0 failed, 5 skipped, and the Playwright journey passed, 1 of 1. Those counts come from the first job's review, before the handover patch and the follow-up. The follow-up then ran the backend unit tests (235 of 240 packages passing, 0 failed) and five other project checks (format, lint and the API description), all passing; it did not run the integration or browser suites again.
The pull request
On our public fork, against the baseline "Gitea main, 1 Nov 2026, just after release
28.3.0" (1f51d2c). Two commits: the job (with its handover's patch), then the follow-up's API guard and tests. The requirement as typed is
its description, with the first review's result.
The browser test (Playwright)
- A reporter files an issue marked Confidential; its page shows the marker.
- A signed-out visitor gets "not found" at its link, and no row for it in the issue list.
- A repository writer sees it in the list, marked Confidential, and makes it public; the timeline records it.
- The signed-out visitor can then open it.
In the pull request: tests/e2e/issue-confidential.test.ts
Who sees a confidential issue
As settled in the approved brief and PRD, from the security lead's answers.
| Viewer | Sees it | Can mark it confidential or public |
|---|---|---|
| The author, even an outside reporter | Yes, while they can read the repository's issues | Only when filing it |
| Assignees | Yes, while assigned | No, unless also a writer |
| Write access or higher on issues: writers, repository admins, organisation owners | Yes | Yes, at any time |
| Site administrators | Yes, except through a public-only token | Yes |
| People with read access only | No: "not found" | Only on an issue they file (then they are its author) |
| Other signed-in users, anonymous visitors | No: "not found", exactly as for a missing issue | Signed-in users only on an issue they file (as its author); anonymous visitors no |
The numbers
1 forge token = $1. The job used 121.20 forge tokens and the follow-up 3.15 (124.35 in all). forge SaaS values a follow-up together with the job it follows, against the one approved estimate. Review time is the minutes our team had each gate open during the filmed run, across both jobs; your own reviewers may need longer, and the calculator below lets you set your own.
The value of the work at your rate
forge wrote this estimate into the PRD, before any design or code existed: the hours a conventional team that knows the codebase would need, by role. Our team approved it at the PRD gate, acting as Northwind's product manager. So we estimated it and we approved it: judge the hours yourself in the table below (the approved estimate in full). If you think they are high, pick a lower number.
$20, $50 and $100 per hour are only examples. Type your own team's rate ($1 to $1,000).
We price the low end of the approved estimate by default. Type your own number of hours if you judge the estimate differently.
From the filmed run: the minutes our team had each gate open. Set your own if your reviewers would take longer.
| Approved estimate, by role | Low | Likely | High |
|---|---|---|---|
| The hours by role arrive with the filmed run. | |||
How this is worked out
- Value = the conventional hours (the approved estimate's low, likely or high end, or your own number) × your hourly rate.
- Cost = the job's forge tokens × $1 + the review hours × your hourly rate.
- Return = value ÷ cost, also shown as value minus cost.
- Hours become person-days of 8 working hours.
- forge made the estimate before the design and the code, so it could not be tuned to the result, and our team approved it at the PRD gate in the role of Northwind's product manager. We price its low end unless you choose otherwise. We call it the value of the work at your rate because your team might not have done this work at all.
Check it yourself
- The pull requestThe code and the tests, on our fork of Gitea, in two commits; the requirement as typed is its description.
- The run reportTime, review minutes, forge tokens, the approved estimate and every gate decision with the feedback word for word, for both jobs, in forge tokens only.
- The whole run as a time-lapseAbout one minute (MP4): every screenshot the recorder took, every 15 seconds, from the job's start to the follow-up's commit on the pull request.
Credits and licence
Gitea is open-source software by the Gitea Authors, released under
the MIT licence. We used it as a real codebase for
this demo on our own public fork, github.com/Gshingala/gitea,
starting from 1f51d2c on the branch demo/3217-baseline.
No endorsement by the Gitea project is implied. Nothing is promised about a pull request to Gitea itself. Two open draft pull requests in Gitea touch nearby areas (#39673, security advisories and private vulnerability reporting; #40123, which limits listings and searches to what a viewer may read); neither implements confidential issues, checked on 3 Nov 2026. Northwind Product Co is fictional.
Put forge on your own backlog
Bring one feature request. You set the credit cap in forge tokens (1 forge token = $1), your team approves each stage, and the job stops at the cap.