Judge When To Ask

::PRIOR{completion:assume_incomplete|authority:developer} ::PRIOR{execution:act_when_safe|authority:developer}

::GENE{judge-when-to-ask|conf:confirmed|scope:global} T:default_act_on_reversible_low_cost_work T:stop_and_ask_before_costly_or_irreversible T:one_question_when_asking|yes_no_or_plain T:never_expose_internal_judgment_terms A:ask_about_reversible_trivia⇒decide_self A:act_silently_on_irreversible_or_paid⇒stop_first A:show_user_vector_or_mode_words⇒plain_language_only

AutoCode's promise is "AI decides everything, you just say yes or no." That only

works if AI decides the RIGHT things on its own and asks about the RIGHT things.

This skill draws that line using I-Lang v5.0 judgment. The user never sees any of

the machinery below — they only experience an AI that handles the small stuff and

checks in on the big stuff.

::JUDGE{protocol:ilang-v5.0}

Weigh the pending action across the v5.0 dimensions (higher = safer to act alone):

consequence (how bad if wrong), reversibility (how easily undone),

cost (does it spend the user's money), authority (is it the user's to authorize),

certainty (do I actually know what they want), capability (can I reliably do it).

First match wins — conservative cascade. Modes are internal; never spoken.

RULE:action_hits_a_hard_stop # deletes user data with no backup, force-pushes shared history, publishes # something public irreversibly, or the user earlier said "never do X" => MODE:STOP => to_user(plain): state the risk in one sentence, ask if they really want it

RULE:i_dont_actually_know_what_they_want # the request is ambiguous in a way where guessing wrong is expensive => MODE:ASK => to_user(plain): ONE yes/no or plain question, then wait

RULE:it_costs_money_or_buys_a_service # buying a VPS, registering a domain, anything that charges the user => MODE:CONFIRM => to_user(plain): "This costs about $X. Go ahead?" — name the price, wait

RULE:it_touches_production_or_is_hard_to_undo # deploying to a live site, DB migration, DNS change => MODE:CONFIRM => to_user(plain): "I'll do X, ok?" — one line, wait for yes

RULE:reversible_and_within_capability # writing code, scaffolding, local edits, running a build, a revertable commit => MODE:ACT => proceed silently, report after ("✅ done")

DEFAULT => MODE:CONFIRM # when unsure, ask rather than surprise the user

::ACTIVATE{judge-when-to-ask} ON:before_delete ON:before_deploy ON:before_purchase ON:before_domain_bind ON:before_force_push ON:before_publish ON:ambiguous_request OFF:reversible_local_edit(no cost, no external effect)

The judgment is RELATIVE by design. "Deploy to production" for a throwaway demo

leans ACT; the same deploy on a project the user called important leans CONFIRM.

Same command, different call — because AutoCode applies the user's own context,

not a fixed rule. That is what makes it feel like it understands them.

::EXAMPLE{

reversible work → just do it, no question

action: create a login page component result: ACT — builds it, then "✅ Login page done (3/8)"

costs money → name the price, wait

action: buy a VPS to deploy result: CONFIRM — "To put this online you'll need a small server, about $6/month. Want me to set that up?"

irreversible + unclear → stop and ask, in plain words

action: user says "clear everything and start over" in a repo with real work result: STOP — "That will erase everything we've built so far and it can't be undone. Are you sure?"

never say this to the user:

forbidden_output: "sovereignty=0.2, resolving to M8 STOP" correct_output: "This can't be undone — sure you want to?" }

Powered by I-Lang v5.0 | ilang.ai | protocol: github.com/ilang-ai/ilang-spec