diff --git a/src/coreclr/nativeaot/Runtime/EHHelpers.cpp b/src/coreclr/nativeaot/Runtime/EHHelpers.cpp
index b888d530c4c5f9..85a6aed6dee861 100644
--- a/src/coreclr/nativeaot/Runtime/EHHelpers.cpp
+++ b/src/coreclr/nativeaot/Runtime/EHHelpers.cpp
@@ -195,7 +195,7 @@ EXTERN_C int32_t __stdcall RhpPInvokeExceptionGuard(PEXCEPTION_RECORD       pExc
 
     // If the thread is currently in the "do not trigger GC" mode, we must not allocate, we must not reverse pinvoke, or
     // return from a pinvoke.  All of these things will deadlock with the GC and they all become increasingly likely as
-    // exception dispatch kicks off.  So we just nip this in the bud as early as possible with a FailFast.  The most
+    // exception dispatch kicks off.  So we just address this as early as possible with a FailFast.  The most
     // likely case where this occurs is in our GC-callouts for Jupiter lifetime management -- in that case, we have
     // managed code that calls to native code (without pinvoking) which might have a bug that causes an AV.
     if (pThread->IsDoNotTriggerGcSet())
diff --git a/src/coreclr/nativeaot/Runtime/eventtrace.cpp b/src/coreclr/nativeaot/Runtime/eventtrace.cpp
index 0f4646152165b1..fd10ac2874ac46 100644
--- a/src/coreclr/nativeaot/Runtime/eventtrace.cpp
+++ b/src/coreclr/nativeaot/Runtime/eventtrace.cpp
@@ -2496,8 +2496,8 @@ void ETW::TypeSystemLog::SendObjectAllocatedEvent(Object* pObject)
         // over 10K in size.
         if (size < 10000 && typeLoggingInfo.dwAllocsSkippedForSample < typeLoggingInfo.dwAllocsToSkipPerSample)
         {
-            // Update hash table's copy of type logging info with these values.  Sucks that
-            // we're doing another hash table lookup here.  Could instead have used LookupPtr()
+            // Update hash table's copy of type logging info with these values. Unfortunate that
+            // we're doing another hash table lookup here. Could instead have used LookupPtr()
             // if it gave us back a non-const pointer, and then we could have updated in-place
             AddOrReplaceTypeLoggingInfo(pLoggedTypesFromModule, &typeLoggingInfo);
             if (fCreatedNew)
diff --git a/src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/BindingFlagSupport/MethodPolicies.cs b/src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/BindingFlagSupport/MethodPolicies.cs
index 41b6452300c4f1..a88d9b76b1cee8 100644
--- a/src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/BindingFlagSupport/MethodPolicies.cs
+++ b/src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/BindingFlagSupport/MethodPolicies.cs
@@ -38,7 +38,7 @@ public sealed override void GetMemberAttributes(MethodInfo member, out MethodAtt
 
         public sealed override bool ImplicitlyOverrides(MethodInfo baseMember, MethodInfo derivedMember)
         {
-            // TODO (https://github.com/dotnet/corert/issues/1896) Comparing signatures is lame. The runtime and/or toolchain should have a way of sharing this info.
+            // TODO (https://github.com/dotnet/corert/issues/1896) Comparing signatures is fragile. The runtime and/or toolchain should have a way of sharing this info.
             return AreNamesAndSignaturesEqual(baseMember, derivedMember);
         }
 
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/CompilerTypeSystemContext.BoxedTypes.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/CompilerTypeSystemContext.BoxedTypes.cs
index 39a6bf3490beb0..beba5d59dc8528 100644
--- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/CompilerTypeSystemContext.BoxedTypes.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/CompilerTypeSystemContext.BoxedTypes.cs
@@ -278,7 +278,7 @@ public BoxedValueType(ModuleDesc owningModule, MetadataType valuetype)
             {
                 // BoxedValueType has the same genericness as the valuetype it's wrapping.
                 // Making BoxedValueType wrap the genericness (and be itself nongeneric) would
-                // require a crazy name mangling scheme to allow generating stable and unique names
+                // require a name mangling scheme to allow generating stable and unique names
                 // for the wrappers.
                 Debug.Assert(valuetype.IsTypeDefinition);
 
@@ -390,7 +390,7 @@ public GenericUnboxingThunk(BoxedValueType owningType, MethodDesc targetMethod)
             {
                 Debug.Assert(targetMethod.OwningType.IsValueType);
                 Debug.Assert(!targetMethod.Signature.IsStatic);
-                
+
                 _owningType = owningType;
                 _targetMethod = targetMethod;
                 _nakedTargetMethod = new ValueTypeInstanceMethodWithHiddenParameter(targetMethod);
@@ -574,7 +574,7 @@ public ValueTypeInstanceMethodWithHiddenParameter(MethodDesc methodRepresented)
             {
                 Debug.Assert(methodRepresented.OwningType.IsValueType);
                 Debug.Assert(!methodRepresented.Signature.IsStatic);
-                
+
                 _methodRepresented = methodRepresented;
             }