diff --git a/src/cmd/pr/write.rs b/src/cmd/pr/write.rs
index 0fc01fe..78752d0 100644
--- a/src/cmd/pr/write.rs
+++ b/src/cmd/pr/write.rs
@@ -260,6 +260,23 @@ pub(crate) async fn create(args: CreateArgs) -> Result<()> {
         })?;
     }
 
+    // Marks are the branch saying it means to be several pull requests, and
+    // this command files it as one. Not a refusal — a stack is not always
+    // what somebody wants, and marks left over from a stack that has landed
+    // are ordinary — but the one moment where saying so costs nothing and
+    // silence costs a pull request that has to be closed by hand.
+    let marked = crate::cmd::stack::marks::recorded(&branch);
+    if !marked.is_empty() {
+        crate::term::say::note!(
+            Git,
+            "{branch} has {} mark(s) on it ({}), which `atgc stack create` would file as \
+             separate pull requests\n\
+             this files the whole branch as one",
+            marked.len(),
+            marked.join(", "),
+        );
+    }
+
     let commits = gitpatch::commit_count(&base)?;
     if commits == 0 {
         // `Usage`, for the reason exit.rs gives the whole class: the branch
diff --git a/src/cmd/stack/write.rs b/src/cmd/stack/write.rs
index 7147a32..1a6e8fd 100644
--- a/src/cmd/stack/write.rs
+++ b/src/cmd/stack/write.rs
@@ -639,9 +639,9 @@ async fn create_inner(args: CreateArgs, rewritten: &mut Option<gitpatch::Rewrite
     {
         crate::term::say::note!(
             Git,
-            "`atgc stack rebase` moves these marks with their commits; a plain `git rebase` \
-             leaves them behind unless --update-refs is used\n\
-             `git config rebase.updateRefs true` makes that git's default here too"
+            "keep this stack in step with `atgc stack sync`, which rebases and reconciles \
+             together; a plain `git rebase` leaves these marks behind unless it is given \
+             --update-refs"
         );
     }
     if args.dry_run {
@@ -2054,6 +2054,20 @@ async fn resubmit_inner(
     if commits.is_empty() {
         bail!("no commits between {base} and HEAD; nothing to reconcile the stack with");
     }
+    // A reconcile against a target that has moved is not wrong — the records
+    // describe the branch, and the branch is what it is — but the patches it
+    // writes are patches against an old base, and every one of them is a
+    // conflict waiting at merge time. Said once, here, because this is the
+    // moment somebody is looking at the stack and could fix it in one
+    // command.
+    if !args.json && !git::is_ancestor(&base, "HEAD") {
+        crate::term::say::note!(
+            Git,
+            "{base} has moved since this branch left it, so these rounds carry patches \
+             against the old base\n\
+             `atgc stack sync` rebases and reconciles in one go"
+        );
+    }
     refuse_merges(&base)?;
 
     // Everything that does not depend on the branch is settled before the
diff --git a/tests/stack_flows.rs b/tests/stack_flows.rs
index 6febfe7..4d149b5 100644
--- a/tests/stack_flows.rs
+++ b/tests/stack_flows.rs
@@ -1744,3 +1744,51 @@ fn a_checkout_can_say_once_that_it_wants_a_pull_per_commit() {
     world.run(&["stack", "create"]).success();
     assert_eq!(world.pulls(ALICE).len(), 4);
 }
+
+/// `pr create` on a marked branch says the marks are there.
+///
+/// Marks mean somebody meant several pull requests; this command files one.
+/// Not a refusal — marks left over from a landed stack are ordinary, and a
+/// stack is not always wanted — but silence here costs a pull request that
+/// has to be closed by hand.
+#[test]
+fn pr_create_says_when_the_branch_has_marks_on_it() {
+    let world = Scenario::new("pr-create-marked");
+    three_commit_branch(&world);
+    world.run(&["stack", "mark", "HEAD~1"]).success();
+
+    let run = world
+        .run(&["pr", "create", "--title", "one pull"])
+        .success();
+
+    assert!(
+        run.stderr.contains("mark(s) on it") && run.stderr.contains("middle"),
+        "the marks went unmentioned:\n{}",
+        run.stderr
+    );
+    // And it really did file one pull request, not a stack.
+    assert_eq!(world.pulls(ALICE).len(), 1);
+}
+
+/// A reconcile against a target that has moved says so, and names the one
+/// command that fixes it — the rounds it is about to write carry patches
+/// against a base nothing has any more.
+#[test]
+fn resubmitting_behind_the_target_points_at_sync() {
+    let world = published_stack("resubmit-behind");
+    world.checkout.git(&["checkout", "-q", "main"]);
+    world
+        .checkout
+        .commit("unrelated.txt", "theirs\n", "feat: landed meanwhile", None);
+    world.checkout.sync_remote("main");
+    world.checkout.git(&["checkout", "-q", "feature"]);
+    world.checkout.amend_file("three.txt", "three, revised\n");
+
+    let run = world.run(&["stack", "resubmit"]).success();
+
+    assert!(
+        run.stderr.contains("atgc stack sync"),
+        "a stack behind its target should be told the one-command fix:\n{}",
+        run.stderr
+    );
+}