I recently updated the public LogFabric website using Cursor, Claude, and a human-controlled PR workflow.

This was not a demo.

It was a real website PR, and I used it to dogfood my own cursor-pr-discipline workflow.

The old website copy was still focused on Stripe post-payment operations.

The current focus is different: human-controlled AI PR workflows for Cursor.

So I opened a small PR and used my own workflow while doing the update.

What I’m building

I’m building cursor-pr-discipline.

It is a lightweight workflow governance pack for Cursor users who use AI-assisted coding but still want pull requests to stay:

• scoped
• reviewable
• human-decided

The goal is not to make AI autonomous.

The goal is to make AI-assisted work easier to review before a human decides what gets merged.

The PR scope

The initial scope was simple:

Update the public homepage copy to align with cursor-pr-discipline Pro Pack v0.

The files eventually changed were:

• index.html
• privacy.html
• terms.html

The important part was not just changing the homepage.

The privacy policy and terms page also needed to match the new product direction.

Otherwise, the homepage would say one thing, while the legal/supporting pages would still describe an older product idea.

How I used Cursor

I used Cursor for the first pass.

The instruction was intentionally narrow:

Only modify the homepage copy.

Cursor quickly updated the main landing page from the old post-payment operations positioning to the new Human-controlled AI PR workflow positioning.

It updated the hero, product sections, roadmap, and calls to action.

This part was fast.

The useful part was not that Cursor “did everything.”

The useful part was that it produced a reviewable change quickly.

Where the human review mattered

After the homepage looked good, I checked for old business terms.

I searched for terms like:

• Stripe
• post-payment
• subscription
• Webhook
• MongoDB
• early access

The homepage was clean.

But while checking the site manually, I noticed something else:

The footer links worked, but the privacy policy and terms page content still described the old product direction.

That was a human judgment point.

The PR scope had to be updated.

Not expanded randomly.

Updated deliberately.

The new scope became:

Update the public LogFabric website copy to align with cursor-pr-discipline Pro Pack v0.

Files in scope:

• index.html
• privacy.html
• terms.html

Out of scope:

• README changes
• layout redesign
• product ZIP changes
• .cursor/rules/
• unrelated implementation work

How I used Claude

For the privacy policy and terms page, I used Claude with a narrow instruction.

The task was not to create a complex legal document.

The task was to remove old product references and align the pages with the current product model:

• digital ZIP product
• delivered through Gumroad
• Cursor .mdc rules
• examples
• decision templates
• no customer repository access
• no customer production secrets
• no custom setup support
• rules are instructions, not enforcement

Claude updated only privacy.html and terms.html.

Then I reviewed the result manually.

What I did not delegate to AI

I did not delegate the final decision.

The human-controlled parts were:

• deciding the PR scope
• deciding that privacy and terms pages were in scope
• checking old wording
• checking local links
• reviewing the final diff
• committing only the intended files
• confirming .cursor/ was not committed
• creating and merging the PR
• checking the live website after merge

This is the point of the workflow.

AI can propose and edit.

But the human decides what belongs in the PR and whether it should be merged.

One important detail: local rules were not committed

During the dogfooding, I used local Cursor rules.

But those rule files were not part of the website PR.

They were local working materials.

Before pushing, I removed the local .cursor/ directory and confirmed the working tree was clean.

That matters because workflow rules and product files should not accidentally leak into unrelated PRs.

Result

The PR updated the public website copy and supporting pages.

It was merged.

The live site was checked after merge.

The workflow worked as intended:

Cursor helped move quickly.

Claude helped with a narrow follow-up edit.

The human kept the PR bounded, reviewed the public-facing consistency, and made the merge decision.

Takeaway

For AI-assisted development, the risky part is not only whether the AI can generate code or copy.

The risky part is whether the work stays scoped and reviewable.

In this small PR, the pattern was:

AI assisted.

Human reviewed.

Human decided.

That is the workflow I want cursor-pr-discipline to support.

---

Related:

• Free Pack on GitHub: https://github.com/logfabricteam/cursor-pr-discipline
• Pro Pack v0 on Gumroad: https://kubo03.gumroad.com/l/cursor-pr-discipline