diff --git a/DistFiles/Language Explorer/Configuration/Grammar/areaConfiguration.xml b/DistFiles/Language Explorer/Configuration/Grammar/areaConfiguration.xml
index 219ac94e8c..a5b11aaa9f 100644
--- a/DistFiles/Language Explorer/Configuration/Grammar/areaConfiguration.xml	
+++ b/DistFiles/Language Explorer/Configuration/Grammar/areaConfiguration.xml	
@@ -426,7 +426,11 @@
 					<recordList owner="MorphologicalData" property="Phonemes"/>
 		</clerk>
 				<clerk id="naturalClasses">
-					<recordList owner="MorphologicalData" property="NaturalClasses"/>
+					<dynamicloaderinfo assemblyPath="MorphologyEditorDll.dll"
+						class="SIL.FieldWorks.XWorks.MorphologyEditor.NaturalClassRecordClerk"/>
+					<recordList owner="MorphologicalData" property="NaturalClasses">
+					  <dynamicloaderinfo assemblyPath="MorphologyEditorDll.dll" class="SIL.FieldWorks.XWorks.MorphologyEditor.NaturalClassRecordList"/>
+					</recordList>
 				</clerk>
 				<clerk id="environments">
 					<recordList owner="MorphologicalData" property="Environments"/>
diff --git a/Src/LexText/Morphology/AffixRuleFormulaControl.cs b/Src/LexText/Morphology/AffixRuleFormulaControl.cs
index 96d776c50b..e2dba908c2 100644
--- a/Src/LexText/Morphology/AffixRuleFormulaControl.cs
+++ b/Src/LexText/Morphology/AffixRuleFormulaControl.cs
@@ -841,7 +841,9 @@ public override void SetMappingNaturalClass(SelectionHelper sel = null)
 			var natClasses = new HashSet<ICmObject>();
 			foreach (var nc in m_cache.LangProject.PhonologicalDataOA.NaturalClassesOS)
 			{
-				if (nc.ClassID == PhNCFeaturesTags.kClassId)
+				// Rule mappings only allow feature-based, user-defined natural classes
+				// to be selected.
+				if (nc is IPhNCFeatures featNC && IsFeatureBasedNCUserDefined(featNC))
 					natClasses.Add(nc);
 			}
 			var selectedNc = DisplayChooser(MEStrings.ksRuleNCOpt, MEStrings.ksRuleNCChooserLink,
diff --git a/Src/LexText/Morphology/AffixRuleFormulaSlice.cs b/Src/LexText/Morphology/AffixRuleFormulaSlice.cs
index 8a54d8fa56..8c7f5a872a 100644
--- a/Src/LexText/Morphology/AffixRuleFormulaSlice.cs
+++ b/Src/LexText/Morphology/AffixRuleFormulaSlice.cs
@@ -62,7 +62,11 @@ public bool OnMappingSetNaturalClass(object args)
 		public bool OnDisplayMappingJumpToNaturalClass(object commandObject, ref XCore.UIItemDisplayProperties display)
 		{
 			CheckDisposed();
-			bool enable = AffixRuleFormulaControl.IsNCIndexCurrent;
+			// Note that a mapping's Natural Class is always feature-based.
+			// For feature-based NCs, we only want to allow jumping to the NC
+			// if it is user-defined.
+			var mapping = AffixRuleFormulaControl.CurrentObject as IMoModifyFromInput;
+			bool enable = mapping != null && RuleFormulaControl.IsFeatureBasedNCUserDefined(mapping.ModificationRA);
 			display.Enabled = enable;
 			display.Visible = enable;
 			return true;
diff --git a/Src/LexText/Morphology/MEStrings.Designer.cs b/Src/LexText/Morphology/MEStrings.Designer.cs
index 348735476b..6bd7a70311 100644
--- a/Src/LexText/Morphology/MEStrings.Designer.cs
+++ b/Src/LexText/Morphology/MEStrings.Designer.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
 //     Runtime Version:4.0.30319.42000
@@ -770,11 +770,22 @@ internal static string ksRuleNCFeatsName {
                 return ResourceManager.GetString("ksRuleNCFeatsName", resourceCulture);
             }
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Natural Class.
-        /// </summary>
-        internal static string ksRuleNCOpt {
+
+		/// <summary>
+		///   Looks up a localized string similar to Shared: {0}.
+		/// </summary>
+		internal static string ksRuleNCSharedNameFormat
+		{
+			get
+			{
+				return ResourceManager.GetString("ksRuleNCSharedNameFormat", resourceCulture);
+			}
+		}
+
+		/// <summary>
+		///   Looks up a localized string similar to Natural Class.
+		/// </summary>
+		internal static string ksRuleNCOpt {
             get {
                 return ResourceManager.GetString("ksRuleNCOpt", resourceCulture);
             }
diff --git a/Src/LexText/Morphology/MEStrings.resx b/Src/LexText/Morphology/MEStrings.resx
index e0cca24438..72c0a6d309 100644
--- a/Src/LexText/Morphology/MEStrings.resx
+++ b/Src/LexText/Morphology/MEStrings.resx
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <root>
   <!-- 
     Microsoft ResX Schema 
@@ -239,6 +239,9 @@
   <data name="ksRuleNCFeatsName" xml:space="preserve">
     <value>Created automatically for rule "{0}"</value>
   </data>
+  <data name="ksRuleNCSharedNameFormat" xml:space="preserve">
+    <value>Shared: {0}</value>
+  </data>
   <data name="ksRuleRedoInsert" xml:space="preserve">
     <value>Redo Insert {0}</value>
   </data>
diff --git a/Src/LexText/Morphology/MorphologyEditorDllTests/NaturalClassRecordListTests.cs b/Src/LexText/Morphology/MorphologyEditorDllTests/NaturalClassRecordListTests.cs
new file mode 100644
index 0000000000..2688c7d806
--- /dev/null
+++ b/Src/LexText/Morphology/MorphologyEditorDllTests/NaturalClassRecordListTests.cs
@@ -0,0 +1,109 @@
+// Copyright (c) 2026 SIL International
+// This software is licensed under the LGPL, version 2.1 or later
+// (http://www.gnu.org/licenses/lgpl-2.1.html)
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using SIL.LCModel;
+
+namespace SIL.FieldWorks.XWorks.MorphologyEditor
+{
+	/// <summary>
+	/// Tests to confirm that <see cref="NaturalClassRecordList"/> includes every
+	/// natural class except a feature-based one generated automatically for a rule.
+	/// </summary>
+	[TestFixture]
+	public class NaturalClassRecordListTests : RuleFormulaVcTestBase
+	{
+		private IEnumerable<int> NCRecordList(params ICmObject[] natClasses)
+		{
+			return NaturalClassRecordList.ExcludeAutoGenerated(
+				natClasses.Select(nc => nc.Hvo), Cache);
+		}
+		[Test]
+		public void AutoGeneratedClass_IsExcluded()
+		{
+			IPhNCFeatures natClass = AddAutoGeneratedFeatureNaturalClass("s to n",
+				new Dictionary<string, string> { { "vd", "+" } });
+
+			// Since the only NC is autogenerated, the NC record list should be empty
+			Assert.That(NCRecordList(natClass), Is.Empty);
+		}
+
+		[Test]
+		public void NamedFeatureClass_IsIncluded()
+		{
+			IPhNCFeatures natClass = AddFeatureNaturalClass("Voiced", "Vd",
+				new Dictionary<string, string> { { "vd", "+" } });
+
+			Assert.That(NCRecordList(natClass), Is.EqualTo(new[] { natClass.Hvo }));
+		}
+
+		/// <summary>
+		/// A feature-based class the user creates starts with no name, so an unnamed class must
+		/// be included for the user to be able to name it.
+		/// </summary>
+		[Test]
+		public void UnnamedFeatureClass_IsIncluded()
+		{
+			IPhNCFeatures natClass = AddFeatureNaturalClass(null, null,
+				new Dictionary<string, string> { { "vd", "+" } });
+
+			Assert.That(NCRecordList(natClass), Is.EqualTo(new[] { natClass.Hvo }));
+		}
+
+		[Test]
+		public void SegmentClass_IsIncluded()
+		{
+			IPhNCSegments natClass = AddSegmentNaturalClass("Vowels", "V");
+
+			Assert.That(NCRecordList(natClass), Is.EqualTo(new[] { natClass.Hvo }));
+		}
+
+		/// <summary>
+		/// A class given an abbreviation by the user is considered user defined,
+		/// so it should display in the NC list.
+		/// </summary>
+		[Test]
+		public void AbbreviatedGeneratedClass_IsIncluded()
+		{
+			IPhNCFeatures natClass = AddAutoGeneratedFeatureNaturalClass("s to n",
+				new Dictionary<string, string> { { "vd", "+" } });
+			natClass.Abbreviation.SetAnalysisDefaultWritingSystem("Vd");
+
+			Assert.That(NCRecordList(natClass), Is.EqualTo(new[] { natClass.Hvo }));
+		}
+
+		/// <summary>
+		/// A class with the "shared" prefix is not considered user defined if it is used
+		/// by at most one rule, so it should not display in the NC list.
+		/// </summary>
+		[Test]
+		public void PrefixedClassUsedByOneRule_IsExcluded()
+		{
+			IPhNCFeatures natClass = AddAutoGeneratedFeatureNaturalClass("s to n",
+				new Dictionary<string, string> { { "vd", "+" } });
+			natClass.Name.SetUserWritingSystem(string.Format(MEStrings.ksRuleNCSharedNameFormat,
+				natClass.Name.UserDefaultWritingSystem.Text));
+			AddStrucDescNCContext(AddRegularRule("rule A"), natClass);
+
+			Assert.That(NCRecordList(natClass), Is.Empty);
+		}
+
+		/// <summary>
+		/// A class used by more than one rule is considered user defined,
+		/// so it should display in the NC list.
+		/// </summary>
+		[Test]
+		public void ClassSharedByTwoRules_IsIncluded()
+		{
+			IPhNCFeatures natClass = AddAutoGeneratedFeatureNaturalClass("s to n",
+				new Dictionary<string, string> { { "vd", "+" } });
+			AddStrucDescNCContext(AddRegularRule("rule A"), natClass);
+			AddStrucDescNCContext(AddRegularRule("rule B"), natClass);
+
+			Assert.That(NCRecordList(natClass), Is.EqualTo(new[] { natClass.Hvo }));
+		}
+	}
+}
diff --git a/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaControlNaturalClassNameTests.cs b/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaControlNaturalClassNameTests.cs
index 17e2139aa2..6059087da4 100644
--- a/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaControlNaturalClassNameTests.cs
+++ b/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaControlNaturalClassNameTests.cs
@@ -11,9 +11,17 @@
 namespace SIL.FieldWorks.XWorks.MorphologyEditor
 {
 	/// <summary>
-	/// Which feature-based natural classes count as carrying a name the user gave them. This is
-	/// the single input deciding whether a rule formula draws a class as an abbreviation or as a
-	/// feature list, so each shape of name a project can hold is pinned here.
+	/// Tests which feature-based natural classes count as user defined.
+	/// A user defined NC must either:
+	/// 1. have a name or abbreviation the user gave it.
+	/// 2. be shared by two or more rules.
+	///
+	/// A rule formula draws a user defined class as an abbreviation and draws an
+	/// auto-generated class as a feature list.
+	///
+	/// Combinations of user given, generated, or absent name/abbrevation and shared
+	/// status are tested here to confirm that NCs are correctly classified as
+	/// user defined or auto-generated.
 	/// </summary>
 	[TestFixture]
 	public class RuleFormulaControlNaturalClassNameTests : RuleFormulaVcTestBase
@@ -21,56 +29,62 @@ public class RuleFormulaControlNaturalClassNameTests : RuleFormulaVcTestBase
 		[Test]
 		public void NoClass_IsNotUserDefined()
 		{
-			Assert.That(RuleFormulaControl.IsFeatureBasedNCNameUserDefined(null), Is.False);
+			Assert.That(RuleFormulaControl.IsFeatureBasedNCUserDefined(null), Is.False);
 		}
 
 		/// <summary>
-		/// The check answers whether a class carries a name the user gave it, and an unnamed
-		/// class carries none. Set Phonological Features relies on that answer to keep
-		/// offering feature edits on unnamed classes (LT-22576).
+		/// A user defined class can have no name, while an auto-generated one will always have
+		/// a generated name. Check that if the class has no name, it is flagged as user defined.
 		/// </summary>
 		[Test]
-		public void ClassWithNoName_IsNotUserDefined()
+		public void ClassWithNoName_IsUserDefined()
 		{
 			IPhNCFeatures natClass = AddFeatureNaturalClass(null, "Vd",
 				new FeatVals { { "vd", "+" } });
 
-			Assert.That(RuleFormulaControl.IsFeatureBasedNCNameUserDefined(natClass), Is.False,
-				"an unnamed class carries no name the user gave it");
+			Assert.That(RuleFormulaControl.IsFeatureBasedNCUserDefined(natClass), Is.True,
+				"an unnamed class must be user defined");
 		}
 
+		/// <summary>
+		/// A user defined class can have an empty name, while an auto-generated one will always
+		/// have a nonempty generated name. Check that if the class's name is empty,
+		/// it is flagged as user defined.
+		/// </summary>
 		[Test]
-		public void ClassWithAnEmptyName_IsNotUserDefined()
+		public void ClassWithAnEmptyName_IsUserDefined()
 		{
 			IPhNCFeatures natClass = AddFeatureNaturalClass(string.Empty, "Vd",
 				new FeatVals { { "vd", "+" } });
 
-			Assert.That(RuleFormulaControl.IsFeatureBasedNCNameUserDefined(natClass), Is.False,
-				"an empty name is not a name the user gave the class");
+			Assert.That(RuleFormulaControl.IsFeatureBasedNCUserDefined(natClass), Is.True,
+				"a class with an empty name must be user defined");
 		}
 
 		[Test]
 		public void ClassNamedForARule_IsNotUserDefined()
 		{
-			IPhNCFeatures natClass = AddRuleNamedFeatureNaturalClass("s to n",
+			IPhNCFeatures natClass = AddAutoGeneratedFeatureNaturalClass("s to n",
 				new FeatVals { { "vd", "+" } });
 
-			Assert.That(RuleFormulaControl.IsFeatureBasedNCNameUserDefined(natClass), Is.False);
+			Assert.That(RuleFormulaControl.IsFeatureBasedNCUserDefined(natClass), Is.False);
 		}
 
 		/// <summary>
-		/// Projects hold rule-generated names that carry a prefix ahead of the generated text, so
-		/// the generated text is recognised wherever it sits in the name.
+		/// If a project contains a NC whose name was generated but a user has added text before
+		/// or after the generated name, it is user defined.
 		/// </summary>
 		[Test]
-		public void ClassNamedForARuleBehindAPrefix_IsNotUserDefined()
+		public void ClassNamedForARuleWithUserAssignedPrefixOrPostfix_IsUserDefined()
 		{
 			IPhNCFeatures natClass = AddFeatureNaturalClass(null, null,
 				new FeatVals { { "vd", "+" } });
 			natClass.Name.SetUserWritingSystem("Phonemes s and t - "
 				+ string.Format(MEStrings.ksRuleNCFeatsName, "s to n"));
-
-			Assert.That(RuleFormulaControl.IsFeatureBasedNCNameUserDefined(natClass), Is.False);
+			Assert.That(RuleFormulaControl.IsFeatureBasedNCUserDefined(natClass), Is.True);
+			natClass.Name.SetUserWritingSystem(string.Format(MEStrings.ksRuleNCFeatsName, "s to n")
+				+ " - phonemes s and t");
+			Assert.That(RuleFormulaControl.IsFeatureBasedNCUserDefined(natClass), Is.True);
 		}
 
 		[Test]
@@ -79,7 +93,7 @@ public void NamedClass_IsUserDefined()
 			IPhNCFeatures natClass = AddFeatureNaturalClass("Voiced", "Vd",
 				new FeatVals { { "vd", "+" } });
 
-			Assert.That(RuleFormulaControl.IsFeatureBasedNCNameUserDefined(natClass), Is.True);
+			Assert.That(RuleFormulaControl.IsFeatureBasedNCUserDefined(natClass), Is.True);
 		}
 
 		/// <summary>
@@ -101,7 +115,7 @@ public void ClassNamedInAnAnalysisWritingSystemOtherThanTheUserOne_IsUserDefined
 				"the name must reach the check through the analysis writing system, "
 				+ "not through a placeholder");
 
-			Assert.That(RuleFormulaControl.IsFeatureBasedNCNameUserDefined(natClass), Is.True);
+			Assert.That(RuleFormulaControl.IsFeatureBasedNCUserDefined(natClass), Is.True);
 		}
 
 		[Test]
@@ -109,8 +123,198 @@ public void NamedClassWithNoFeatures_IsUserDefined()
 		{
 			IPhNCFeatures natClass = AddFeatureNaturalClass("Voiced", "Vd", new FeatVals());
 
-			Assert.That(RuleFormulaControl.IsFeatureBasedNCNameUserDefined(natClass), Is.True,
+			Assert.That(RuleFormulaControl.IsFeatureBasedNCUserDefined(natClass), Is.True,
 				"a name qualifies a class whatever it carries for features");
 		}
+
+		/// <summary>
+		/// No class is neither user defined nor auto-generated.
+		/// </summary>
+		[Test]
+		public void NullClass_IsNotAutoGenerated()
+		{
+			Assert.That(RuleFormulaControl.IsAutoGeneratedNaturalClass(null), Is.False);
+		}
+
+		/// <summary>
+		/// A translation may put the rule name first, leaving no generated text before the
+		/// placeholder. Its generated names are still recognized, but ordinary names are not.
+		/// </summary>
+		[Test]
+		public void FormatStartingWithRuleName_RecognisesGeneratedName()
+		{
+			const string format = "{0} rule: created automatically";
+
+			Assert.That(RuleFormulaControl.IsAutoGeneratedName(string.Format(format, "s to n"), format),
+				Is.True, "a name generated from the format is recognized");
+			Assert.That(RuleFormulaControl.IsAutoGeneratedName("Voiced", format), Is.False,
+				"an empty stub before the rule name must not match every name");
+		}
+
+		/// <summary>
+		/// A translation lacking the rule name placeholder must not break recognition; no name
+		/// counts as generated from it.
+		/// </summary>
+		[Test]
+		public void FormatWithoutPlaceholder_RecognisesNothing()
+		{
+			const string format = "Created automatically for rule";
+
+			Assert.That(RuleFormulaControl.IsAutoGeneratedName(format, format), Is.False);
+		}
+
+		/// <summary>
+		/// An otherwise generated class with an abbreviation added by the user is considered
+		/// user defined.
+		/// </summary>
+		[Test]
+		public void GeneratedNameWithAbbreviation_IsUserDefined()
+		{
+			IPhNCFeatures natClass = AddAutoGeneratedFeatureNaturalClass("s to n",
+				new FeatVals { { "vd", "+" } });
+			natClass.Abbreviation.SetAnalysisDefaultWritingSystem("Vd");
+
+			Assert.That(RuleFormulaControl.IsFeatureBasedNCUserDefined(natClass), Is.True);
+		}
+
+		/// <summary>
+		/// An abbreviation of only spaces is not one the user gave the class.
+		/// </summary>
+		[Test]
+		public void GeneratedNameWithWhitespaceAbbreviation_IsNotUserDefined()
+		{
+			IPhNCFeatures natClass = AddAutoGeneratedFeatureNaturalClass("s to n",
+				new FeatVals { { "vd", "+" } });
+			natClass.Abbreviation.SetAnalysisDefaultWritingSystem("   ");
+
+			Assert.That(RuleFormulaControl.IsFeatureBasedNCUserDefined(natClass), Is.False);
+		}
+
+		/// <summary>
+		/// An abbreviation should be recognized in any WS.
+		/// </summary>
+		[Test]
+		public void GeneratedNameWithAbbreviationInAnotherAnalysisWs_IsUserDefined()
+		{
+			Cache.ServiceLocator.WritingSystemManager.GetOrSet("de",
+				out CoreWritingSystemDefinition german);
+			Cache.LanguageProject.AddToCurrentAnalysisWritingSystems(german);
+			IPhNCFeatures natClass = AddAutoGeneratedFeatureNaturalClass("s to n",
+				new FeatVals { { "vd", "+" } });
+			natClass.Abbreviation.set_String(german.Handle,
+				TsStringUtils.MakeString("Sth", german.Handle));
+
+			Assert.That(RuleFormulaControl.IsFeatureBasedNCUserDefined(natClass), Is.True);
+		}
+
+		// Formats for the IsAutoGeneratedName overload tests, independent of the resources.
+		private const string GeneratedFormat = "Created automatically for rule \"{0}\"";
+		private const string PrefixFormat = "Shared: {0}";
+		private const string GeneratedName = "Created automatically for rule \"s to n\"";
+		private const string PrefixedName = "Shared: " + GeneratedName;
+
+		// Stand-ins for a translation, in ASCII.
+		private const string OtherGeneratedFormat = "Cree automatiquement pour la regle <{0}>";
+		private const string OtherPrefixFormat = "Partage : {0}";
+
+		// A plain generated name without the shared prefix should be recognized as generated.
+		[TestCase(GeneratedName, true, false, GeneratedName)]
+
+		// A generated name with the shared prefix should be recognized as generated.
+		[TestCase(PrefixedName, true, true, GeneratedName)]
+
+		// A name with extra text before or after the generated name should not be recognized
+		// as generated.
+		[TestCase("Extra " + PrefixedName, false, false, null)]
+		[TestCase(PrefixedName + " extra", false, false, null)]
+
+		// A name that is not generated should not be recognized as generated.
+		[TestCase("Voiced", false, false, null)]
+		public void IsAutoGeneratedName_ReportsPrefixAndUnprefixedName(string ncName,
+			bool expectedResult, bool expectedHasSharedPrefix, string expectedUnprefixedName)
+		{
+			bool result = RuleFormulaControl.IsAutoGeneratedName(ncName,
+				new[] { GeneratedFormat }, new[] { PrefixFormat },
+				out bool hasSharedPrefix, out string unlabelledName);
+
+			Assert.That(result, Is.EqualTo(expectedResult));
+			Assert.That(hasSharedPrefix, Is.EqualTo(expectedHasSharedPrefix));
+			Assert.That(unlabelledName, Is.EqualTo(expectedUnprefixedName));
+		}
+
+		/// <summary>
+		/// A prefixed name counts as auto-generated; it must also count as prefixed.
+		/// </summary>
+		[Test]
+		public void RuleFirstFormat_WithPrefixBeforeTheName_IsRecognisedAsPrefixed()
+		{
+			const string format = "{0} rule: created automatically";
+			string generated = string.Format(format, "s to n");
+
+			bool result = RuleFormulaControl.IsAutoGeneratedName("Shared: " + generated,
+				new[] { format }, new[] { PrefixFormat },
+				out bool hasSharedPrefix, out string unlabelledName);
+
+			Assert.That(result, Is.True);
+			Assert.That(hasSharedPrefix, Is.True);
+			Assert.That(unlabelledName, Is.EqualTo(generated));
+		}
+
+		/// <summary>
+		/// A prefixed name counts as auto-generated for languages where the prefix comes
+		/// after the name; it must also count as prefixed.
+		/// </summary>
+		[Test]
+		public void RuleFirstFormat_WithPrefixTextAfterTheName_IsRecognisedAsPrefixed()
+		{
+			const string format = "{0} rule: created automatically";
+			string generated = string.Format(format, "s to n");
+
+			bool result = RuleFormulaControl.IsAutoGeneratedName(generated + " Shared:",
+				new[] { format }, new[] { "{0} Shared:" },
+				out bool hasSharedPrefix, out string unlabelledName);
+
+			Assert.That(result, Is.True);
+			Assert.That(hasSharedPrefix, Is.True);
+			Assert.That(unlabelledName, Is.EqualTo(generated));
+		}
+
+		/// <summary>
+		/// A prefix added while the prefix was untranslated is in English, around a generated
+		/// name in the interface language.
+		/// </summary>
+		[Test]
+		public void EnglishPrefixAroundOtherLanguageName_IsRecognisedAsPrefixed()
+		{
+			string generated = string.Format(OtherGeneratedFormat, "s to n");
+
+			bool result = RuleFormulaControl.IsAutoGeneratedName("Shared: " + generated,
+				new[] { OtherGeneratedFormat, GeneratedFormat },
+				new[] { OtherPrefixFormat, PrefixFormat },
+				out bool hasSharedPrefix, out string unlabelledName);
+
+			Assert.That(result, Is.True);
+			Assert.That(hasSharedPrefix, Is.True);
+			Assert.That(unlabelledName, Is.EqualTo(generated));
+		}
+
+		/// <summary>
+		/// A name generated while the format was untranslated, or under an English interface,
+		/// is recognized after the interface language's formats.
+		/// </summary>
+		[TestCase(GeneratedName, false)]
+		[TestCase(PrefixedName, true)]
+		public void EnglishName_IsRecognisedAfterOtherLanguageFormats(string ncName,
+			bool expectedHasSharedPrefix)
+		{
+			bool result = RuleFormulaControl.IsAutoGeneratedName(ncName,
+				new[] { OtherGeneratedFormat, GeneratedFormat },
+				new[] { OtherPrefixFormat, PrefixFormat },
+				out bool hasSharedPrefix, out string unlabelledName);
+
+			Assert.That(result, Is.True);
+			Assert.That(hasSharedPrefix, Is.EqualTo(expectedHasSharedPrefix));
+			Assert.That(unlabelledName, Is.EqualTo(GeneratedName));
+		}
 	}
 }
diff --git a/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaControlSharedNaturalClassTests.cs b/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaControlSharedNaturalClassTests.cs
new file mode 100644
index 0000000000..5f778e8977
--- /dev/null
+++ b/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaControlSharedNaturalClassTests.cs
@@ -0,0 +1,269 @@
+// Copyright (c) 2026 SIL International
+// This software is licensed under the LGPL, version 2.1 or later
+// (http://www.gnu.org/licenses/lgpl-2.1.html)
+
+using NUnit.Framework;
+using SIL.LCModel;
+using FeatVals = System.Collections.Generic.Dictionary<string, string>;
+
+namespace SIL.FieldWorks.XWorks.MorphologyEditor
+{
+	/// <summary>
+	/// A natural class with a generated name counts as user defined once two or more distinct
+	/// rules use it, and stays auto-generated while at most one rule does. Each case varies
+	/// only what refers to the class.
+	/// </summary>
+	[TestFixture]
+	public class RuleFormulaControlSharedNaturalClassTests : RuleFormulaVcTestBase
+	{
+		private IPhNCFeatures AddGeneratedClass()
+		{
+			return AddAutoGeneratedFeatureNaturalClass("s to n", new FeatVals { { "vd", "+" } });
+		}
+
+		private static bool IsUserDefined(IPhNCFeatures natClass)
+		{
+			return RuleFormulaControl.IsFeatureBasedNCUserDefined(natClass);
+		}
+
+		/// <summary>
+		/// Adds a sequence context owned as the left context of <paramref name="rhs"/>, the
+		/// way the rule editor holds an environment of more than one item. The members must
+		/// already be owned.
+		/// </summary>
+		private IPhSequenceContext AddRuleOwnedSequenceContext(IPhSegRuleRHS rhs,
+			params IPhPhonContext[] members)
+		{
+			IPhSequenceContext ctxt =
+				Cache.ServiceLocator.GetInstance<IPhSequenceContextFactory>().Create();
+			rhs.LeftContextOA = ctxt;
+			foreach (IPhPhonContext member in members)
+				ctxt.MembersRS.Add(member);
+			return ctxt;
+		}
+
+		/// <summary>
+		/// Adds an output mapping to <paramref name="rule"/> that modifies its input with
+		/// <paramref name="natClass"/>.
+		/// </summary>
+		private IMoModifyFromInput AddModifyMapping(IMoAffixProcess rule, IPhNCFeatures natClass)
+		{
+			IMoModifyFromInput mapping =
+				Cache.ServiceLocator.GetInstance<IMoModifyFromInputFactory>().Create();
+			rule.OutputOS.Add(mapping);
+			mapping.ModificationRA = natClass;
+			return mapping;
+		}
+
+		/// <summary>
+		/// Adds an environment whose left context is <paramref name="ctxt"/>, used by an affix
+		/// allomorph of a new entry.
+		/// </summary>
+		private IPhEnvironment AddEnvironmentUsedByAnAllomorph(IPhPhonContext ctxt)
+		{
+			IPhEnvironment env =
+				Cache.ServiceLocator.GetInstance<IPhEnvironmentFactory>().Create();
+			Cache.LanguageProject.PhonologicalDataOA.EnvironmentsOS.Add(env);
+			env.LeftContextRA = ctxt;
+			ILexEntry entry = Cache.ServiceLocator.GetInstance<ILexEntryFactory>().Create();
+			IMoAffixAllomorph allomorph =
+				Cache.ServiceLocator.GetInstance<IMoAffixAllomorphFactory>().Create();
+			entry.AlternateFormsOS.Add(allomorph);
+			allomorph.PhoneEnvRC.Add(env);
+			return env;
+		}
+
+		[Test]
+		public void AutoNamedClassUsedByTwoRegularRules_IsUserDefined()
+		{
+			IPhNCFeatures natClass = AddGeneratedClass();
+			AddStrucDescNCContext(AddRegularRule("rule A"), natClass);
+			AddStrucDescNCContext(AddRegularRule("rule B"), natClass);
+
+			Assert.That(IsUserDefined(natClass), Is.True);
+		}
+
+		[Test]
+		public void AutoNamedClassUsedByRegularAndMetathesisRules_IsUserDefined()
+		{
+			IPhNCFeatures natClass = AddGeneratedClass();
+			AddStrucDescNCContext(AddRegularRule("rule A"), natClass);
+			AddMetathesisNCContext(AddMetathesisRule("rule B"),
+				PhMetathesisRuleTags.kidxLeftSwitch, natClass);
+
+			Assert.That(IsUserDefined(natClass), Is.True);
+		}
+
+		[Test]
+		public void AutoNamedClassUsedByRegularAndAffixProcessRules_IsUserDefined()
+		{
+			IPhNCFeatures natClass = AddGeneratedClass();
+			AddStrucDescNCContext(AddRegularRule("rule A"), natClass);
+			AddInputNCContext(AddAffixProcessRule(), natClass);
+
+			Assert.That(IsUserDefined(natClass), Is.True);
+		}
+
+		[Test]
+		public void AutoNamedClassUsedByTwoAffixProcessMappings_IsUserDefined()
+		{
+			IPhNCFeatures natClass = AddGeneratedClass();
+			AddModifyMapping(AddAffixProcessRule(), natClass);
+			AddModifyMapping(AddAffixProcessRule(), natClass);
+
+			Assert.That(IsUserDefined(natClass), Is.True);
+		}
+
+		/// <summary>
+		/// A member of a multi-item environment is owned by the phonological data, so it
+		/// reaches its rule only through the sequence context that rule owns.
+		/// </summary>
+		[Test]
+		public void AutoNamedClassReachedThroughSequenceContext_IsUserDefined()
+		{
+			IPhNCFeatures natClass = AddGeneratedClass();
+			AddRuleOwnedSequenceContext(AddRegularRule("rule A"),
+				AddStandaloneNCContext(natClass));
+			AddStrucDescNCContext(AddRegularRule("rule B"), natClass);
+
+			Assert.That(IsUserDefined(natClass), Is.True);
+		}
+
+		[Test]
+		public void AutoNamedClassReachedThroughIterationInSequence_IsUserDefined()
+		{
+			IPhNCFeatures natClass = AddGeneratedClass();
+			IPhIterationContext iteration = AddIterationContext(AddStandaloneNCContext(natClass));
+			AddRuleOwnedSequenceContext(AddRegularRule("rule A"), iteration);
+			AddStrucDescNCContext(AddRegularRule("rule B"), natClass);
+
+			Assert.That(IsUserDefined(natClass), Is.True);
+		}
+
+		/// <summary>
+		/// One context object refers to the class, yet two rules use that context.
+		/// </summary>
+		[Test]
+		public void ContextSharedBySequencesInTwoRules_IsUserDefined()
+		{
+			IPhNCFeatures natClass = AddGeneratedClass();
+			IPhSimpleContextNC sharedCtxt = AddStandaloneNCContext(natClass);
+			AddRuleOwnedSequenceContext(AddRegularRule("rule A"), sharedCtxt);
+			AddRuleOwnedSequenceContext(AddRegularRule("rule B"), sharedCtxt);
+
+			Assert.That(IsUserDefined(natClass), Is.True);
+		}
+
+		[Test]
+		public void AutoNamedClassUsedByOneRule_IsNotUserDefined()
+		{
+			IPhNCFeatures natClass = AddGeneratedClass();
+			AddStrucDescNCContext(AddRegularRule("rule A"), natClass);
+
+			Assert.That(IsUserDefined(natClass), Is.False);
+		}
+
+		[Test]
+		public void AutoNamedClassUsedTwiceInOneRule_IsNotUserDefined()
+		{
+			IPhNCFeatures natClass = AddGeneratedClass();
+			IPhSegRuleRHS rhs = AddRegularRule("rule A");
+			AddStrucDescNCContext(rhs, natClass);
+			AddStrucChangeNCContext(rhs, natClass);
+
+			Assert.That(IsUserDefined(natClass), Is.False);
+		}
+
+		[Test]
+		public void AutoNamedClassInAffixInputAndMappingOfOneRule_IsNotUserDefined()
+		{
+			IPhNCFeatures natClass = AddGeneratedClass();
+			IMoAffixProcess rule = AddAffixProcessRule();
+			AddInputNCContext(rule, natClass);
+			AddModifyMapping(rule, natClass);
+
+			Assert.That(IsUserDefined(natClass), Is.False);
+		}
+
+		/// <summary>
+		/// The environment is attached to an allomorph so that a search past the environment
+		/// would have further objects to reach.
+		/// </summary>
+		[Test]
+		public void AutoNamedClassUsedByOneRuleAndAnEnvironment_IsNotUserDefined()
+		{
+			IPhNCFeatures natClass = AddGeneratedClass();
+			AddStrucDescNCContext(AddRegularRule("rule A"), natClass);
+			AddEnvironmentUsedByAnAllomorph(AddStandaloneNCContext(natClass));
+
+			Assert.That(IsUserDefined(natClass), Is.False);
+		}
+
+		[Test]
+		public void AutoNamedClassUsedByOneRuleAndALeftoverContext_IsNotUserDefined()
+		{
+			IPhNCFeatures natClass = AddGeneratedClass();
+			AddStrucDescNCContext(AddRegularRule("rule A"), natClass);
+			AddStandaloneNCContext(natClass);
+
+			Assert.That(IsUserDefined(natClass), Is.False);
+		}
+
+		/// <summary>
+		/// A context one rule owns can also be a member of another rule's sequence context.
+		/// </summary>
+		[Test]
+		public void RuleOwnedContextInAnotherRulesSequence_IsUserDefined()
+		{
+			IPhNCFeatures natClass = AddGeneratedClass();
+			IPhSimpleContextNC ctxt = AddStrucDescNCContext(AddRegularRule("rule A"), natClass);
+			AddRuleOwnedSequenceContext(AddRegularRule("rule B"), ctxt);
+
+			Assert.That(IsUserDefined(natClass), Is.True);
+		}
+
+		[Test]
+		public void SharedClassBecomesAutoGeneratedWhenOneRuleIsDeleted()
+		{
+			IPhNCFeatures natClass = AddGeneratedClass();
+			AddStrucDescNCContext(AddRegularRule("rule A"), natClass);
+			IPhSegRuleRHS rhsB = AddRegularRule("rule B");
+			AddStrucDescNCContext(rhsB, natClass);
+			Assert.That(IsUserDefined(natClass), Is.True, "two rules share the class");
+
+			Cache.LanguageProject.PhonologicalDataOA.PhonRulesOS.Remove(rhsB.OwningRule);
+
+			Assert.That(IsUserDefined(natClass), Is.False);
+		}
+
+		private IPhNCFeatures AddPrefixedGeneratedClass()
+		{
+			IPhNCFeatures natClass = AddGeneratedClass();
+			natClass.Name.SetUserWritingSystem(string.Format(MEStrings.ksRuleNCSharedNameFormat,
+				natClass.Name.UserDefaultWritingSystem.Text));
+			return natClass;
+		}
+
+		/// <summary>
+		/// The shared prefix alone does not make a class the user's; it must actually be used
+		/// by more than one rule to be considered user defined.
+		/// </summary>
+		[Test]
+		public void PrefixedGeneratedNameUsedByOneRule_IsNotUserDefined()
+		{
+			IPhNCFeatures natClass = AddPrefixedGeneratedClass();
+			AddStrucDescNCContext(AddRegularRule("rule A"), natClass);
+
+			Assert.That(IsUserDefined(natClass), Is.False);
+		}
+
+		public void PrefixedGeneratedNameUsedByTwoRules_IsUserDefined()
+		{
+			IPhNCFeatures natClass = AddPrefixedGeneratedClass();
+			AddStrucDescNCContext(AddRegularRule("rule A"), natClass);
+			AddStrucDescNCContext(AddRegularRule("rule B"), natClass);
+
+			Assert.That(IsUserDefined(natClass), Is.True);
+		}
+	}
+}
diff --git a/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaControlSharedPrefixSyncTests.cs b/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaControlSharedPrefixSyncTests.cs
new file mode 100644
index 0000000000..8b4b481807
--- /dev/null
+++ b/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaControlSharedPrefixSyncTests.cs
@@ -0,0 +1,180 @@
+// Copyright (c) 2026 SIL International
+// This software is licensed under the LGPL, version 2.1 or later
+// (http://www.gnu.org/licenses/lgpl-2.1.html)
+
+using NUnit.Framework;
+using SIL.LCModel;
+using SIL.LCModel.Core.Text;
+using SIL.LCModel.Core.WritingSystems;
+using FeatVals = System.Collections.Generic.Dictionary<string, string>;
+
+namespace SIL.FieldWorks.XWorks.MorphologyEditor
+{
+	/// <summary>
+	/// Pins how <see cref="RuleFormulaControl.SyncSharedPrefix"/> and
+	/// <see cref="RuleFormulaControl.SyncSharedPrefixes"/> keep the shared prefix on generated
+	/// natural class names in line with how many rules use each class.
+	/// </summary>
+	[TestFixture]
+	public class RuleFormulaControlSharedPrefixSyncTests : RuleFormulaVcTestBase
+	{
+		private static string GeneratedName =>
+			string.Format(MEStrings.ksRuleNCFeatsName, "s to n");
+
+		private static string PrefixedName =>
+			string.Format(MEStrings.ksRuleNCSharedNameFormat, GeneratedName);
+
+		private IPhNCFeatures AddClassNamed(string name)
+		{
+			IPhNCFeatures natClass = AddFeatureNaturalClass(null, null,
+				new FeatVals { { "vd", "+" } });
+			natClass.Name.SetUserWritingSystem(name);
+			return natClass;
+		}
+
+		private void UseInRules(IPhNaturalClass natClass, int ruleCount)
+		{
+			for (int i = 0; i < ruleCount; i++)
+				AddStrucDescNCContext(AddRegularRule("rule " + i), natClass);
+		}
+
+		private static string NameOf(IPhNaturalClass natClass)
+		{
+			return natClass.Name.UserDefaultWritingSystem.Text;
+		}
+
+		[Test]
+		public void SharedUnprefixedClass_GetsThePrefix()
+		{
+			IPhNCFeatures natClass = AddClassNamed(GeneratedName);
+			UseInRules(natClass, 2);
+
+			Assert.That(RuleFormulaControl.SyncSharedPrefix(natClass), Is.True);
+			Assert.That(NameOf(natClass), Is.EqualTo(PrefixedName));
+		}
+
+		[Test]
+		public void PrefixedClassUsedByOneRule_LosesThePrefix()
+		{
+			IPhNCFeatures natClass = AddClassNamed(PrefixedName);
+			UseInRules(natClass, 1);
+
+			Assert.That(RuleFormulaControl.SyncSharedPrefix(natClass), Is.True);
+			Assert.That(NameOf(natClass), Is.EqualTo(GeneratedName));
+		}
+
+		[Test]
+		public void PrefixedClassUsedByNoRule_LosesThePrefix()
+		{
+			IPhNCFeatures natClass = AddClassNamed(PrefixedName);
+
+			Assert.That(RuleFormulaControl.SyncSharedPrefix(natClass), Is.True);
+			Assert.That(NameOf(natClass), Is.EqualTo(GeneratedName));
+		}
+
+		[Test]
+		public void UnsharedUnprefixedClass_IsUnchanged()
+		{
+			IPhNCFeatures natClass = AddClassNamed(GeneratedName);
+			UseInRules(natClass, 1);
+
+			Assert.That(RuleFormulaControl.SyncSharedPrefix(natClass), Is.False);
+			Assert.That(NameOf(natClass), Is.EqualTo(GeneratedName));
+		}
+
+		[Test]
+		public void SecondSync_ChangesNothing()
+		{
+			IPhNCFeatures natClass = AddClassNamed(GeneratedName);
+			UseInRules(natClass, 2);
+			Assert.That(RuleFormulaControl.SyncSharedPrefix(natClass), Is.True, "first sync");
+
+			Assert.That(RuleFormulaControl.SyncSharedPrefix(natClass), Is.False);
+			Assert.That(NameOf(natClass), Is.EqualTo(PrefixedName));
+		}
+
+		[Test]
+		public void UserEditedName_IsLeftAloneEvenWhenShared()
+		{
+			string editedName = GeneratedName + " - voiced";
+			IPhNCFeatures natClass = AddClassNamed(editedName);
+			UseInRules(natClass, 2);
+
+			Assert.That(RuleFormulaControl.SyncSharedPrefix(natClass), Is.False);
+			Assert.That(NameOf(natClass), Is.EqualTo(editedName));
+		}
+
+		[Test]
+		public void AbbreviatedSharedClass_DoesNotGetThePrefix()
+		{
+			IPhNCFeatures natClass = AddClassNamed(GeneratedName);
+			natClass.Abbreviation.SetAnalysisDefaultWritingSystem("Vd");
+			UseInRules(natClass, 2);
+
+			Assert.That(RuleFormulaControl.SyncSharedPrefix(natClass), Is.False);
+			Assert.That(NameOf(natClass), Is.EqualTo(GeneratedName));
+		}
+
+		[Test]
+		public void NullOrUnnamedClass_IsNotChanged()
+		{
+			IPhNCFeatures unnamed = AddFeatureNaturalClass(null, null,
+				new FeatVals { { "vd", "+" } });
+			UseInRules(unnamed, 2);
+
+			Assert.That(RuleFormulaControl.SyncSharedPrefix(null), Is.False);
+			Assert.That(RuleFormulaControl.SyncSharedPrefix(unnamed), Is.False);
+		}
+
+		/// <summary>
+		/// The name is read with a fallback to other writing systems, so it is rewritten in the
+		/// writing system it was read from rather than added to the user writing system.
+		/// </summary>
+		[Test]
+		public void NameInAnotherAnalysisWs_IsRewrittenInThatWs()
+		{
+			Cache.ServiceLocator.WritingSystemManager.GetOrSet("de",
+				out CoreWritingSystemDefinition german);
+			Cache.LanguageProject.AddToCurrentAnalysisWritingSystems(german);
+			IPhNCFeatures natClass = AddFeatureNaturalClass(null, null,
+				new FeatVals { { "vd", "+" } });
+			natClass.Name.set_String(german.Handle,
+				TsStringUtils.MakeString(PrefixedName, german.Handle));
+			UseInRules(natClass, 1);
+			Assert.That(NameOf(natClass), Is.EqualTo(PrefixedName),
+				"the name must reach the sync through the analysis writing system");
+
+			Assert.That(RuleFormulaControl.SyncSharedPrefix(natClass), Is.True);
+			Assert.That(natClass.Name.get_String(german.Handle).Text,
+				Is.EqualTo(GeneratedName));
+			Assert.That(natClass.Name.get_String(Cache.DefaultUserWs).Text, Is.Null.Or.Empty,
+				"no name is added in the user writing system");
+		}
+
+		[Test]
+		public void SyncSharedPrefixes_BringsEveryClassInLine()
+		{
+			IPhNCFeatures shared = AddClassNamed(GeneratedName);
+			UseInRules(shared, 2);
+			IPhNCFeatures prefixedSingle = AddClassNamed(PrefixedName);
+			UseInRules(prefixedSingle, 1);
+			IPhNCFeatures plainSingle = AddClassNamed(GeneratedName);
+			UseInRules(plainSingle, 1);
+			IPhNCFeatures userNamed = AddFeatureNaturalClass("Voiced", "Vd",
+				new FeatVals { { "vd", "+" } });
+			UseInRules(userNamed, 2);
+			IPhNCSegments segmentClass = AddSegmentNaturalClass("Vowels", "V");
+
+			Assert.That(RuleFormulaControl.SyncSharedPrefixes(Cache), Is.True);
+			Assert.That(NameOf(shared), Is.EqualTo(PrefixedName));
+			Assert.That(NameOf(prefixedSingle), Is.EqualTo(GeneratedName));
+			Assert.That(NameOf(plainSingle), Is.EqualTo(GeneratedName));
+			Assert.That(NameOf(userNamed), Is.EqualTo("Voiced"));
+			Assert.That(segmentClass.Name.AnalysisDefaultWritingSystem.Text,
+				Is.EqualTo("Vowels"));
+
+			Assert.That(RuleFormulaControl.SyncSharedPrefixes(Cache), Is.False,
+				"a second pass changes nothing");
+		}
+	}
+}
diff --git a/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaVcNaturalClassDependencyTests.cs b/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaVcNaturalClassDependencyTests.cs
index c8f2f59105..39ae080cfc 100644
--- a/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaVcNaturalClassDependencyTests.cs
+++ b/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaVcNaturalClassDependencyTests.cs
@@ -40,7 +40,7 @@ public void RegularRule_RegistersTheNameAndAbbreviationOfItsClass()
 		[Test]
 		public void RegularRule_RegistersTheNameOfARuleNamedClass()
 		{
-			IPhNCFeatures natClass = AddRuleNamedFeatureNaturalClass("s to n",
+			IPhNCFeatures natClass = AddAutoGeneratedFeatureNaturalClass("s to n",
 				new FeatVals { { "vd", "+" } });
 			IPhSegRuleRHS rhs = AddRegularRule("s to n");
 			AddStrucDescNCContext(rhs, natClass);
diff --git a/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaVcNaturalClassDisplayTests.cs b/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaVcNaturalClassDisplayTests.cs
index d4f6469427..13fee8ac6d 100644
--- a/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaVcNaturalClassDisplayTests.cs
+++ b/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaVcNaturalClassDisplayTests.cs
@@ -65,18 +65,18 @@ public void NamedClass_WithEmptyAbbreviation_DrawsStars()
 		}
 
 		[Test]
-		public void RuleNamedClass_WithOneFeature_DrawsFeature()
+		public void AutoGeneratedClass_WithOneFeature_DrawsFeature()
 		{
-			IPhNCFeatures natClass = AddRuleNamedFeatureNaturalClass("s to n",
+			IPhNCFeatures natClass = AddAutoGeneratedFeatureNaturalClass("s to n",
 				new FeatVals { { "vd", "+" } });
 
 			Assert.That(DrawContext(AddStandaloneNCContext(natClass)), Is.EqualTo("[+ vd]"));
 		}
 
 		[Test]
-		public void RuleNamedClass_WithThreeFeatures_DrawsEveryFeatureInAPile()
+		public void AutoGeneratedClass_WithThreeFeatures_DrawsEveryFeatureInAPile()
 		{
-			IPhNCFeatures natClass = AddRuleNamedFeatureNaturalClass("s to n",
+			IPhNCFeatures natClass = AddAutoGeneratedFeatureNaturalClass("s to n",
 				new FeatVals { { "vd", "+" }, { "cons", "+" }, { "cont", "-" } });
 
 			string drawn = DrawContext(AddStandaloneNCContext(natClass));
@@ -90,26 +90,25 @@ public void RuleNamedClass_WithThreeFeatures_DrawsEveryFeatureInAPile()
 		}
 
 		[Test]
-		public void RuleNamedClass_WithNoFeatures_DrawsQuestions()
+		public void AutoGeneratedClass_WithNoFeatures_DrawsQuestions()
 		{
-			IPhNCFeatures natClass = AddRuleNamedFeatureNaturalClass("s to n", new FeatVals());
+			IPhNCFeatures natClass = AddAutoGeneratedFeatureNaturalClass("s to n", new FeatVals());
 
 			Assert.That(DrawContext(AddStandaloneNCContext(natClass)), Is.EqualTo("[???]"));
 		}
 
 		/// <summary>
-		/// Whether a class was generated for a rule decides the drawing, not what its
-		/// abbreviation says: a generated class keeps its feature list even after someone
-		/// abbreviates it "C".
+		/// An otherwise auto-generated class with an added abbreviation is considered
+		/// user defined, so its abbreviation should display instead of its feature list.
 		/// </summary>
 		[Test]
-		public void RuleNamedClass_AbbreviatedC_DrawsFeature()
+		public void AutoGeneratedClass_AbbreviatedC_DrawsAbbreviation()
 		{
-			IPhNCFeatures natClass = AddRuleNamedFeatureNaturalClass("s to n",
+			IPhNCFeatures natClass = AddAutoGeneratedFeatureNaturalClass("s to n",
 				new FeatVals { { "cons", "+" } });
 			natClass.Abbreviation.SetAnalysisDefaultWritingSystem("C");
 
-			Assert.That(DrawContext(AddStandaloneNCContext(natClass)), Is.EqualTo("[+ cons]"));
+			Assert.That(DrawContext(AddStandaloneNCContext(natClass)), Is.EqualTo("[C]"));
 		}
 
 		/// <summary>
@@ -117,9 +116,9 @@ public void RuleNamedClass_AbbreviatedC_DrawsFeature()
 		/// editor, so from then on the formula draws its abbreviation instead of its features.
 		/// </summary>
 		[Test]
-		public void RuleNamedClass_OnceNamed_DrawsAbbreviation()
+		public void AutoGeneratedClass_OnceNamed_DrawsAbbreviation()
 		{
-			IPhNCFeatures natClass = AddRuleNamedFeatureNaturalClass("s to n",
+			IPhNCFeatures natClass = AddAutoGeneratedFeatureNaturalClass("s to n",
 				new FeatVals { { "vd", "+" } });
 			IPhSimpleContextNC ctxt = AddStandaloneNCContext(natClass);
 			Assert.That(DrawContext(ctxt), Is.EqualTo("[+ vd]"), "before the class is named");
diff --git a/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaVcNaturalClassSizingTests.cs b/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaVcNaturalClassSizingTests.cs
index 991e79e2e4..8d5c23287e 100644
--- a/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaVcNaturalClassSizingTests.cs
+++ b/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaVcNaturalClassSizingTests.cs
@@ -52,7 +52,7 @@ public void NamedClass_WithNoAbbreviation_IsSizedToTheStars()
 		[Test]
 		public void RuleNamedClass_WithOneFeature_IsSizedToItsFeature()
 		{
-			IPhNCFeatures natClass = AddRuleNamedFeatureNaturalClass("s to n",
+			IPhNCFeatures natClass = AddAutoGeneratedFeatureNaturalClass("s to n",
 				new FeatVals { { "vd", "+" } });
 
 			AssertCellMatchesDrawing(AddStandaloneNCContext(natClass), "[+ vd]");
@@ -70,7 +70,7 @@ public void NamedClass_WithThreeFeatures_OccupiesOneLine()
 		[Test]
 		public void RuleNamedClass_WithThreeFeatures_OccupiesOneLinePerFeature()
 		{
-			IPhNCFeatures natClass = AddRuleNamedFeatureNaturalClass("s to n",
+			IPhNCFeatures natClass = AddAutoGeneratedFeatureNaturalClass("s to n",
 				new FeatVals { { "vd", "+" }, { "cons", "+" }, { "cont", "-" } });
 
 			Assert.That(NumLinesFor(AddStandaloneNCContext(natClass)), Is.EqualTo(3));
diff --git a/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaVcTestBase.cs b/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaVcTestBase.cs
index 7ba2075b2c..54c8d2348c 100644
--- a/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaVcTestBase.cs
+++ b/Src/LexText/Morphology/MorphologyEditorDllTests/RuleFormulaVcTestBase.cs
@@ -93,10 +93,10 @@ protected IPhNCFeatures AddFeatureNaturalClass(string name, string abbreviation,
 		}
 
 		/// <summary>
-		/// Adds a feature-based natural class named the way one built for a rule is named, in the
-		/// user writing system and with no abbreviation.
+		/// Adds a feature-based natural class named the way one auto-generated for a rule
+		/// is named, in the user writing system and with no abbreviation.
 		/// </summary>
-		protected IPhNCFeatures AddRuleNamedFeatureNaturalClass(string ruleName, FeatVals featVals)
+		protected IPhNCFeatures AddAutoGeneratedFeatureNaturalClass(string ruleName, FeatVals featVals)
 		{
 			IPhNCFeatures natClass = AddFeatureNaturalClass(null, null, featVals);
 			natClass.Name.SetUserWritingSystem(string.Format(MEStrings.ksRuleNCFeatsName, ruleName));
diff --git a/Src/LexText/Morphology/NaturalClassRecordClerk.cs b/Src/LexText/Morphology/NaturalClassRecordClerk.cs
new file mode 100644
index 0000000000..b32af5398d
--- /dev/null
+++ b/Src/LexText/Morphology/NaturalClassRecordClerk.cs
@@ -0,0 +1,33 @@
+// Copyright (c) 2026 SIL International
+// This software is licensed under the LGPL, version 2.1 or later
+// (http://www.gnu.org/licenses/lgpl-2.1.html)
+
+using SIL.LCModel.Infrastructure;
+
+namespace SIL.FieldWorks.XWorks.MorphologyEditor
+{
+	/// <summary>
+	/// A record clerk over natural classes that keeps the "shared" prefix on generated natural
+	/// class names current, so whether a prefix exists matches whether more than one rule uses
+	/// the class.
+	/// </summary>
+	public class NaturalClassRecordClerk : RecordClerk
+	{
+		/// <summary>
+		/// Brings the "shared" prefix on every generated natural class name up to date
+		/// before the list is shown. A prefix change means the class may have joined or
+		/// left the list to display, so the list is reloaded when any prefix changes.
+		/// </summary>
+		public override void ActivateUI(bool useRecordTreeBar, bool updateStatusBar = true)
+		{
+			bool changed = false;
+			NonUndoableUnitOfWorkHelper.Do(Cache.ActionHandlerAccessor,
+				() => changed = RuleFormulaControl.SyncSharedPrefixes(Cache));
+			// A class whose name changed may have gained or lost its place in the list.
+			if (changed)
+				m_list.ReloadList();
+
+			base.ActivateUI(useRecordTreeBar, updateStatusBar);
+		}
+	}
+}
diff --git a/Src/LexText/Morphology/NaturalClassRecordList.cs b/Src/LexText/Morphology/NaturalClassRecordList.cs
new file mode 100644
index 0000000000..5e9f392552
--- /dev/null
+++ b/Src/LexText/Morphology/NaturalClassRecordList.cs
@@ -0,0 +1,32 @@
+// Copyright (c) 2026 SIL International
+// This software is licensed under the LGPL, version 2.1 or later
+// (http://www.gnu.org/licenses/lgpl-2.1.html)
+
+using System.Collections.Generic;
+using System.Linq;
+using SIL.LCModel;
+
+namespace SIL.FieldWorks.XWorks.MorphologyEditor
+{
+	/// <summary>
+	/// Exclude all auto-generated feature-based natural classes from the NC record list.
+	/// </summary>
+	public class NaturalClassRecordList : RecordList
+	{
+		protected override IEnumerable<int> GetObjectSet()
+		{
+			return ExcludeAutoGenerated(base.GetObjectSet(), m_cache);
+		}
+
+		/// <summary>
+		/// The given natural class HVOs, less the feature-based classes generated automatically
+		/// for a rule.
+		/// </summary>
+		internal static IEnumerable<int> ExcludeAutoGenerated(IEnumerable<int> hvos, LcmCache cache)
+		{
+			var repo = cache.ServiceLocator.GetInstance<ICmObjectRepository>();
+			return hvos.Where(hvo =>
+				!RuleFormulaControl.IsAutoGeneratedNaturalClass(repo.GetObject(hvo) as IPhNaturalClass));
+		}
+	}
+}
diff --git a/Src/LexText/Morphology/RuleFormulaControl.cs b/Src/LexText/Morphology/RuleFormulaControl.cs
index ab19d20a68..e88b723104 100644
--- a/Src/LexText/Morphology/RuleFormulaControl.cs
+++ b/Src/LexText/Morphology/RuleFormulaControl.cs
@@ -4,11 +4,13 @@
 
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Xml;
 using System.Windows.Forms;
 using SIL.FieldWorks.Common.FwUtils;
 using SIL.LCModel;
+using SIL.LCModel.Core.Text;
 using SIL.LCModel.Infrastructure;
 using SIL.FieldWorks.Common.Controls;
 using SIL.FieldWorks.Common.ViewsInterfaces;
@@ -613,7 +615,9 @@ private void m_insertionControl_Insert(object sender, InsertEventArgs e)
 					break;
 
 				case RuleInsertType.NaturalClass:
-					IEnumerable<IPhNaturalClass> natClasses = m_cache.LangProject.PhonologicalDataOA.NaturalClassesOS.OrderBy(natc => natc.ShortName);
+					// show all natural classes that are not auto generated
+					IEnumerable<IPhNaturalClass> natClasses = m_cache.LangProject.PhonologicalDataOA.NaturalClassesOS.Where(natc => !IsAutoGeneratedNaturalClass(natc))
+						.OrderBy(natc => natc.ShortName);
 					ICmObject ncObj = DisplayChooser(MEStrings.ksRuleNCOpt, MEStrings.ksRuleNCChooserLink,
 						"naturalClassedit", "RuleNaturalClassFlatList", natClasses);
 					var nc = ncObj as IPhNaturalClass;
@@ -980,49 +984,328 @@ protected int GetIndexToRemove(ICmObject[] objs, SelectionHelper sel, bool forwa
 
 			return -1;
 		}
+
+		/// <summary>
+		/// True when two or more distinct rules use <paramref name="natClass"/>.
+		/// </summary>
+		internal static bool IsUsedByMoreThanOneRule(IPhNaturalClass natClass)
+		{
+			var rules = new HashSet<ICmObject>();
+			var visited = new HashSet<ICmObject>();
+			foreach (ICmObject referrer in natClass.ReferringObjects)
+			{
+				CollectOwningRules(referrer, rules, visited);
+				if (rules.Count > 1)
+					return true;
+			}
+			return false;
+		}
+
+		private static void CollectOwningRules(ICmObject obj, HashSet<ICmObject> rules,
+			HashSet<ICmObject> visited)
+		{
+			// Skip this object if we've already seen it.
+			if (!visited.Add(obj))
+				return;
+
+			// IPhSegmentRule covers regular or metathesis rules; IMoAffixProcess covers APRs
+			ICmObject rule = (ICmObject)obj.OwnerOfClass<IPhSegmentRule>()
+							 ?? obj.OwnerOfClass<IMoAffixProcess>();
+			if (rule != null)
+			{
+				rules.Add(rule);
+			}
+
+			// If the object isn't a phonological context, any other referring objects are
+			// not rules (they may be environments, allomorphs, etc).
+			if (!(obj is IPhPhonContext))
+				return;
+
+			// If the object is a phonological context, we need to check the referrers of
+			// its referrers for other rules.
+			foreach (ICmObject referrer in obj.ReferringObjects)
+				CollectOwningRules(referrer, rules, visited);
+		}
+
+		/// <summary>
+		/// Brings the "shared" prefix on a generated natural class name in line with how many
+		/// rules use the class: a generated name is prefixed while more than one rule uses the
+		/// class and unprefixed otherwise. Only the name alternative that
+		/// <see cref="IsFeatureBasedNCUserDefined(IPhNCFeatures)"/> reads is changed. A name the
+		/// user has altered, or the name of a class the user has given an abbreviation, is left
+		/// alone. Must be called inside a unit of work.
+		/// </summary>
+		/// <returns>True if the name was changed.</returns>
+		internal static bool SyncSharedPrefix(IPhNCFeatures natClass)
+		{
+			if (natClass == null)
+				return false;
+
+			string ncName = GetNCName(natClass, out int wsName);
+
+			if (!IsAutoGeneratedName(ncName, out bool hasSharedPrefix, out string unprefixedName))
+				return false;
+
+			// A class the user has given an abbreviation is theirs; its name is left as it is.
+			if (HasAbbreviation(natClass))
+				return false;
+
+			bool isShared = IsUsedByMoreThanOneRule(natClass);
+			if (isShared == hasSharedPrefix)
+				return false;
+
+			string newName;
+			if (isShared)
+			{
+				// Shared but not prefixed: add the shared prefix in the interface language.
+				string sharedFormat = MEStrings.ksRuleNCSharedNameFormat;
+				if (sharedFormat.IndexOf("{0}", StringComparison.Ordinal) < 0)
+					return false; // a prefix without the name would lose the name
+				newName = string.Format(sharedFormat, ncName);
+			}
+			else
+			{
+				// Not shared but has shared prefix: remove the prefix, whatever its language.
+				newName = unprefixedName;
+			}
+
+			// Update the NC name. Write the new name back to the writing system the name was
+			// read from.
+			natClass.Name.set_String(wsName, TsStringUtils.MakeString(newName, wsName));
+			return true;
+		}
+
 		/// <summary>
-		/// Returns a bool representing whether the currently selected feature-based natural class simple context is user defined.
+		/// Applies <see cref="SyncSharedPrefix"/> to every feature-based natural class in the
+		/// project. Must be called inside a unit of work.
+		/// </summary>
+		/// <returns>True if any name was changed.</returns>
+		internal static bool SyncSharedPrefixes(LcmCache cache)
+		{
+			var phonData = cache.LangProject.PhonologicalDataOA;
+			if (phonData == null)
+				return false;
+
+			bool changed = false;
+			foreach (IPhNCFeatures natClass in phonData.NaturalClassesOS.OfType<IPhNCFeatures>())
+				changed |= SyncSharedPrefix(natClass);
+			return changed;
+		}
+
+		/// <summary>
+		/// The name that decides whether a natural class is auto-generated: its user writing
+		/// system name, or the alternative that read falls back to. <paramref name="ws"/> is
+		/// the writing system the name came from. Returns null, with <paramref name="ws"/> 0,
+		/// when the class has no name in any writing system.
+		/// </summary>
+		private static string GetNCName(IPhNaturalClass natClass, out int ws)
+		{
+			ws = 0;
+			var name = natClass.Name;
+			// With no name in any writing system, the read gives the "***" placeholder, not
+			// empty text.
+			if (name == null || !name.AvailableWritingSystemIds.Any(
+				id => !string.IsNullOrEmpty(name.get_String(id).Text)))
+				return null;
+			var tssName = name.UserDefaultWritingSystem;
+			if (tssName == null)
+				return null;
+			ws = TsStringUtils.GetWsAtOffset(tssName, 0);
+			return tssName.Text;
+		}
+
+		/// <summary>
+		/// Returns a bool representing whether the currently selected feature-based
+		/// natural class simple context is user defined.
 		/// </summary>
 		/// <comments>
-		/// A user-defined natural class has a name assigned by the user.
-		/// Natural classes are auto-generated when a user assigns phonological features, and they receive auto-generated names of a specific form.
+		/// A user-defined natural class either has no name, has a name assigned by the user,
+		/// has an abbreviation assigned by the user, or has a generated name but the class
+		/// is shared by more than one rule.
+		/// Natural classes are auto-generated when a user assigns phonological features,
+		/// and they receive auto-generated names of a specific form.
 		/// </comments>
 		/// <returns>
-		/// Returns false if the natural class is not feature based, or if it has no name or an auto-generated name.
-		/// Returns true otherwise.
+		/// Returns false if the natural class is not feature based,
+		/// or if it has no abbreviation, and it has an auto-generated name
+		/// and is used by at most one rule.
+		/// Returns true otherwise (including if the class has no name).
 		/// </returns>
-		public bool IsFeatureBasedNCNameUserDefined()
+		public bool IsFeatureBasedNCUserDefined()
 		{
 			// If the class is not feature based, return false.
 			if (!IsFeatsNCContextCurrent){ return false; }
 
 			var ctxt = (IPhSimpleContextNC) CurrentContext;
-			return IsFeatureBasedNCNameUserDefined((IPhNCFeatures)ctxt.FeatureStructureRA);
+			return IsFeatureBasedNCUserDefined((IPhNCFeatures)ctxt.FeatureStructureRA);
 		}
 
 		/// <summary>
-		/// Reports whether a feature-based natural class carries a name the user gave it,
-		/// as opposed to no name or the name generated when phonological features are inserted
-		/// directly into a rule. Returns false when <paramref name="natClass"/> is null.
+		/// Reports whether a feature-based natural class is user defined.
+		/// Returns true if the class has no name or a name that was not auto-generated,
+		/// if the class has an abbreviation, or if the class is used by more than one rule.
+		/// Returns false otherwise, including if <paramref name="natClass"/> is null.
 		/// </summary>
-		public static bool IsFeatureBasedNCNameUserDefined(IPhNCFeatures natClass)
+		public static bool IsFeatureBasedNCUserDefined(IPhNCFeatures natClass)
 		{
 			if (natClass == null)
 				return false;
 
-			// Get the auto-generated text that precedes the rulename. (e.g. extracting "Created automatically for rule "" from "Created automatically for rule "{0}"")
-			// Note that the generated rulename following the stubtext is different for "regular" vs affix rules, but in all cases the auto-generated stub is the same.
-			string autoGeneratedNameStub = (MEStrings.ksRuleNCFeatsName).Split('{')[0];
+			// If the NC name is not auto generated, then the class is user defined.
+			// A user defined NC may have no name, an auto-generated NC always has a
+			// generated name.
+			string ncName = GetNCName(natClass, out _);
 
-			// If the natural class name is not null or auto generated, then it is a user defined class name.
-			// If a class has no name in any WS, it reads back from LCM as the placeholder "***" rather than as empty text,
-			// so we need to manually check whether the name exists in any available WS to determine if the NC is named.
-			var name = natClass.Name;
-			bool isNamed = name != null && name.AvailableWritingSystemIds.Any(ws => !string.IsNullOrEmpty(name.get_String(ws).Text));
-			string ncName = isNamed ? name.UserDefaultWritingSystem?.Text : null;
-			bool isAutoGeneratedOrNull = string.IsNullOrEmpty(ncName) || ncName.Contains(autoGeneratedNameStub);
-			return !isAutoGeneratedOrNull;
+			// Check for a generated name, in the user interface language or in English.
+			// e.g. In English, the name would be "Created automatically for rule "{0}""
+			if (!IsAutoGeneratedName(ncName, out _, out _))
+				return true;
+
+			// A generated class the user has given an abbreviation is treated as user defined.
+			if (HasAbbreviation(natClass))
+				return true;
+
+			// If a generated class is used by more than one rule, the user has chosen to link it
+			// to multiple rules, and it should be treated as user defined.
+			return IsUsedByMoreThanOneRule(natClass);
+		}
+
+		/// <summary>
+		/// True when <paramref name="natClass"/> has a non-blank abbreviation in any
+		/// writing system.
+		/// </summary>
+		private static bool HasAbbreviation(IPhNaturalClass natClass)
+		{
+			var abbr = natClass.Abbreviation;
+			return abbr != null && abbr.AvailableWritingSystemIds.Any(
+				ws => !string.IsNullOrWhiteSpace(abbr.get_String(ws).Text));
+		}
+
+		/// <summary>
+		/// Reports whether <paramref name="ncName"/> is exactly a name generated from
+		/// <paramref name="format"/>, the format string used to name auto-generated natural
+		/// classes (its rule name placeholder is "{0}"). Returns false for a null or empty name,
+		/// and for a format with no placeholder, since generated names can't be recognized
+		/// from it.
+		/// </summary>
+		internal static bool IsAutoGeneratedName(string ncName, string format)
+		{
+			return TryMatchFormat(ncName, format, out _);
+		}
+
+		/// <summary>
+		/// Reports whether <paramref name="ncName"/> is a generated name, either exactly as
+		/// generated from one of <paramref name="formats"/> or wrapped once in one of
+		/// <paramref name="sharedFormats"/>, the prefixes for a generated class used by more
+		/// than one rule. <paramref name="hasSharedPrefix"/> is true only for the wrapped form,
+		/// and <paramref name="unprefixedName"/> is the generated name without any prefix,
+		/// or null when the name is not a generated one.
+		/// </summary>
+		/// <param name="ncName">A Natural Class name. The method checks whether it is
+		/// auto-generated.</param>
+		/// <param name="formats">A list containing the generated name in the interface language,
+		/// as well as in English, the fallback language.</param>
+		/// <param name="sharedFormats">A list containing the shared prefix format in the
+		/// interface language, as well as in English, the fallback language.</param>
+		/// <param name="hasSharedPrefix">A bool indicating whether the NC name includes the
+		/// sharedFormat prefix or not.</param>
+		/// <param name = "unprefixedName">The generated name without any sharedPrefix.
+		/// Given in the interface language if possible, or English as a fallback.</param>
+		internal static bool IsAutoGeneratedName(string ncName, IEnumerable<string> formats,
+			IEnumerable<string> sharedFormats, out bool hasSharedPrefix,
+			out string unprefixedName)
+		{
+			// Shared formats are tried first: when a prefix sits where a generated format has no
+			// fixed text, a prefixed name also fits that format, read as a longer rule name.
+			foreach (string sharedFormat in sharedFormats)
+			{
+				if (TryMatchFormat(ncName, sharedFormat, out string inner)
+					&& formats.Any(format => TryMatchFormat(inner, format, out _)))
+				{
+					hasSharedPrefix = true;
+					unprefixedName = inner;
+					return true;
+				}
+			}
+			hasSharedPrefix = false;
+			unprefixedName = formats.Any(format => TryMatchFormat(ncName, format, out _))
+				? ncName : null;
+			return unprefixedName != null;
 		}
+
+		/// <summary>
+		/// Reports whether <paramref name="ncName"/> is a generated name, prefixed or not,
+		/// using the generated name and prefix formats in the user interface language
+		/// and in the English fallback.
+		/// <paramref name="hasSharedPrefix"/> and <paramref name="unprefixedName"/> are as in
+		/// <see cref="IsAutoGeneratedName(string, IEnumerable{string}, IEnumerable{string},
+		/// bool, string)">
+		/// the overload that takes the formats.
+		/// </summary>
+		private static bool IsAutoGeneratedName(string ncName, out bool hasSharedPrefix,
+			out string unprefixedName)
+		{
+			return IsAutoGeneratedName(ncName,
+				LocalizedWithEnglishFallback(nameof(MEStrings.ksRuleNCFeatsName),
+					MEStrings.ksRuleNCFeatsName),
+				LocalizedWithEnglishFallback(nameof(MEStrings.ksRuleNCSharedNameFormat),
+					MEStrings.ksRuleNCSharedNameFormat),
+				out hasSharedPrefix, out unprefixedName);
+		}
+
+		/// <summary>
+		/// Returns <paramref name="localized"/>, followed by the English text of the
+		/// same resource when it differs. Names written while a string was untranslated,
+		/// or under another interface language, are in English.
+		/// </summary>
+		private static string[] LocalizedWithEnglishFallback(string resourceName, string localized)
+		{
+			string english =
+				MEStrings.ResourceManager.GetString(resourceName, CultureInfo.InvariantCulture);
+			return english == null || english == localized
+				? new[] { localized }
+				: new[] { localized, english };
+		}
+
+		/// <summary>
+		/// Reports whether <paramref name="text"/> is exactly <paramref name="format"/> with some
+		/// text in its "{0}" placeholder, and returns that text in <paramref name="filler"/>.
+		/// Returns false for null or empty text, a null format, or a format with no placeholder.
+		/// </summary>
+		private static bool TryMatchFormat(string text, string format, out string filler)
+		{
+			filler = null;
+			if (string.IsNullOrEmpty(text) || format == null)
+				return false;
+
+			// Different languages put the placeholder before or after the fixed text, so the text
+			// on both sides of it is checked.
+			int placeholderIndex = format.IndexOf("{0}", StringComparison.Ordinal);
+			if (placeholderIndex < 0)
+				return false;
+			string preStub = format.Substring(0, placeholderIndex);
+			string postStub = format.Substring(placeholderIndex + 3);
+
+			// The whole text must be the fixed text around the placeholder; an altered name is
+			// the user's.
+			if (text.Length < preStub.Length + postStub.Length
+				|| !text.StartsWith(preStub, StringComparison.Ordinal)
+				|| !text.EndsWith(postStub, StringComparison.Ordinal))
+				return false;
+			filler = text.Substring(preStub.Length,
+				text.Length - preStub.Length - postStub.Length);
+			return true;
+		}
+
+		/// <summary>
+		/// True for feature-based natural classes generated automatically for a rule.
+		/// Phoneme-based classes are never auto-generated.
+		/// </summary>
+		public static bool IsAutoGeneratedNaturalClass(IPhNaturalClass nc)
+		{
+			return nc is IPhNCFeatures featNC && !IsFeatureBasedNCUserDefined(featNC);
+		}
+
 		/// <summary>
 		/// Sets the phonological features for the currently selected natural class simple context with
 		/// a feature-based natural class.
diff --git a/Src/LexText/Morphology/RuleFormulaSlice.cs b/Src/LexText/Morphology/RuleFormulaSlice.cs
index 0b1be0bb1b..3ad0e079ae 100644
--- a/Src/LexText/Morphology/RuleFormulaSlice.cs
+++ b/Src/LexText/Morphology/RuleFormulaSlice.cs
@@ -153,7 +153,7 @@ public bool OnDisplayContextSetFeatures(object commandObject, ref UIItemDisplayP
 			bool enable = false;
 			if (RuleFormulaControl.IsFeatsNCContextCurrent)
 			{
-				bool isUserDefinedNC = RuleFormulaControl.IsFeatureBasedNCNameUserDefined();
+				bool isUserDefinedNC = RuleFormulaControl.IsFeatureBasedNCUserDefined();
 				enable = !isUserDefinedNC; //enable is true iff IsFeatsNCContextCurrent is true and IsNCNameUserDefined is false
 			}
 
@@ -173,6 +173,12 @@ public bool OnDisplayContextJumpToNaturalClass(object commandObject, ref UIItemD
 		{
 			CheckDisposed();
 			bool enable = RuleFormulaControl.IsNCContextCurrent;
+
+			// If the current context is a feature-based natural class,
+			// we only want to allow jumping to the natural class if it is user-defined.
+			if (RuleFormulaControl.IsFeatsNCContextCurrent)
+				enable = RuleFormulaControl.IsFeatureBasedNCUserDefined();
+
 			display.Enabled = enable;
 			display.Visible = enable;
 			return true;
diff --git a/Src/LexText/Morphology/RuleFormulaVcBase.cs b/Src/LexText/Morphology/RuleFormulaVcBase.cs
index 007c5be9f4..8b2030d269 100644
--- a/Src/LexText/Morphology/RuleFormulaVcBase.cs
+++ b/Src/LexText/Morphology/RuleFormulaVcBase.cs
@@ -135,7 +135,7 @@ public override void Display(IVwEnv vwenv, int hvo, int frag)
 
 								// User-defined feature-based natural classes should display
 								// only the abbreviation.
-								if (RuleFormulaControl.IsFeatureBasedNCNameUserDefined(natClass))
+								if (RuleFormulaControl.IsFeatureBasedNCUserDefined(natClass))
 								{
 									if (!isOuterIterCtxt)
 										OpenSingleLinePile(vwenv, GetMaxNumLines());
@@ -561,7 +561,7 @@ protected int GetNumLines(IPhContextOrVar ctxtOrVar)
 
 						// User-defined, feature-based natural classes should display
 						// only the abbreviation, which is a single line.
-						if (RuleFormulaControl.IsFeatureBasedNCNameUserDefined(natClass))
+						if (RuleFormulaControl.IsFeatureBasedNCUserDefined(natClass))
 							return 1;
 
 						// Otherwise, the list of features is displayed.
@@ -679,7 +679,7 @@ int GetNCCtxtWidth(IPhSimpleContextNC ctxt, IVwEnv vwenv)
 				// User-defined feature-based natural classes display only the abbreviation,
 				// so get width of the abbreviation.
 				var natClass = (IPhNCFeatures)ctxt.FeatureStructureRA;
-				if (RuleFormulaControl.IsFeatureBasedNCNameUserDefined(natClass))
+				if (RuleFormulaControl.IsFeatureBasedNCUserDefined(natClass))
 				{
 					int len = GetStrWidth(ctxt.FeatureStructureRA.Abbreviation.BestAnalysisAlternative, null, vwenv);
 					len += GetStrWidth(m_leftBracket, null, vwenv);