diff --git a/CHANGELOG.next.toml b/CHANGELOG.next.toml
index 7267f1f4e3..06b3ab3d54 100644
--- a/CHANGELOG.next.toml
+++ b/CHANGELOG.next.toml
@@ -29,3 +29,9 @@ message = "Avoid extending IMDS credentials' expiry unconditionally, which may i
 references = ["smithy-rs#2687", "smithy-rs#2694"]
 meta = { "breaking" = false, "tada" = false, "bug" = true }
 author = "ysaito1001"
+
+[[smithy-rs]]
+message = "Fix compiler errors in generated code when naming shapes after types in the Rust standard library prelude."
+references = ["smithy-rs#2696"]
+meta = { "breaking" = false, "tada" = false, "bug" = true, "target" = "client"}
+author = "jdisanti"
diff --git a/aws/sdk-codegen/src/main/kotlin/software/amazon/smithy/rustsdk/AwsFluentClientDecorator.kt b/aws/sdk-codegen/src/main/kotlin/software/amazon/smithy/rustsdk/AwsFluentClientDecorator.kt
index cca5c9f910..d0639dbb81 100644
--- a/aws/sdk-codegen/src/main/kotlin/software/amazon/smithy/rustsdk/AwsFluentClientDecorator.kt
+++ b/aws/sdk-codegen/src/main/kotlin/software/amazon/smithy/rustsdk/AwsFluentClientDecorator.kt
@@ -223,6 +223,7 @@ private fun renderCustomizableOperationSendMethod(
     val combinedGenerics = operationGenerics + handleGenerics
 
     val codegenScope = arrayOf(
+        *RuntimeType.preludeScope,
         "combined_generics_decl" to combinedGenerics.declaration(),
         "handle_generics_bounds" to handleGenerics.bounds(),
         "SdkSuccess" to RuntimeType.sdkSuccess(runtimeConfig),
@@ -238,11 +239,11 @@ private fun renderCustomizableOperationSendMethod(
             #{handle_generics_bounds:W}
         {
             /// Sends this operation's request
-            pub async fn send<T, E>(self) -> Result<T, SdkError<E>>
+            pub async fn send<T, E>(self) -> #{Result}<T, #{SdkError}<E>>
             where
-                E: std::error::Error + Send + Sync + 'static,
-                O: #{ParseHttpResponse}<Output = Result<T, E>> + Send + Sync + Clone + 'static,
-                Retry: #{ClassifyRetry}<#{SdkSuccess}<T>, #{SdkError}<E>> + Send + Sync + Clone,
+                E: std::error::Error + #{Send} + #{Sync} + 'static,
+                O: #{ParseHttpResponse}<Output = #{Result}<T, E>> + #{Send} + #{Sync} + #{Clone} + 'static,
+                Retry: #{ClassifyRetry}<#{SdkSuccess}<T>, #{SdkError}<E>> + #{Send} + #{Sync} + #{Clone},
             {
                 self.handle.client.call(self.operation).await
             }
diff --git a/aws/sdk-codegen/src/main/kotlin/software/amazon/smithy/rustsdk/AwsPresigningDecorator.kt b/aws/sdk-codegen/src/main/kotlin/software/amazon/smithy/rustsdk/AwsPresigningDecorator.kt
index 20d280ddf9..f6a3cd889c 100644
--- a/aws/sdk-codegen/src/main/kotlin/software/amazon/smithy/rustsdk/AwsPresigningDecorator.kt
+++ b/aws/sdk-codegen/src/main/kotlin/software/amazon/smithy/rustsdk/AwsPresigningDecorator.kt
@@ -250,6 +250,7 @@ class AwsPresignedFluentBuilderMethod(
 ) : FluentClientCustomization() {
     private val codegenScope = (
         presigningTypes + arrayOf(
+            *RuntimeType.preludeScope,
             "Error" to AwsRuntimeType.presigning().resolve("config::Error"),
             "SdkError" to RuntimeType.sdkError(runtimeConfig),
         )
@@ -264,7 +265,7 @@ class AwsPresignedFluentBuilderMethod(
                     pub async fn presigned(
                         self,
                         presigning_config: #{PresigningConfig},
-                    ) -> Result<#{PresignedRequest}, #{SdkError}<#{OpError}>>
+                    ) -> #{Result}<#{PresignedRequest}, #{SdkError}<#{OpError}>>
                     """,
                     *codegenScope,
                     "OpError" to section.operationErrorType,
diff --git a/aws/sdk-codegen/src/main/kotlin/software/amazon/smithy/rustsdk/customize/s3/S3Decorator.kt b/aws/sdk-codegen/src/main/kotlin/software/amazon/smithy/rustsdk/customize/s3/S3Decorator.kt
index 664494d021..0a2bd05212 100644
--- a/aws/sdk-codegen/src/main/kotlin/software/amazon/smithy/rustsdk/customize/s3/S3Decorator.kt
+++ b/aws/sdk-codegen/src/main/kotlin/software/amazon/smithy/rustsdk/customize/s3/S3Decorator.kt
@@ -131,6 +131,7 @@ class FilterEndpointTests(
 class S3ProtocolOverride(codegenContext: CodegenContext) : RestXml(codegenContext) {
     private val runtimeConfig = codegenContext.runtimeConfig
     private val errorScope = arrayOf(
+        *RuntimeType.preludeScope,
         "Bytes" to RuntimeType.Bytes,
         "ErrorMetadata" to RuntimeType.errorMetadata(runtimeConfig),
         "ErrorBuilder" to RuntimeType.errorMetadataBuilder(runtimeConfig),
@@ -143,7 +144,7 @@ class S3ProtocolOverride(codegenContext: CodegenContext) : RestXml(codegenContex
     override fun parseHttpErrorMetadata(operationShape: OperationShape): RuntimeType {
         return ProtocolFunctions.crossOperationFn("parse_http_error_metadata") { fnName ->
             rustBlockTemplate(
-                "pub fn $fnName(response_status: u16, _response_headers: &#{HeaderMap}, response_body: &[u8]) -> Result<#{ErrorBuilder}, #{XmlDecodeError}>",
+                "pub fn $fnName(response_status: u16, _response_headers: &#{HeaderMap}, response_body: &[u8]) -> #{Result}<#{ErrorBuilder}, #{XmlDecodeError}>",
                 *errorScope,
             ) {
                 rustTemplate(
diff --git a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/ClientRustModule.kt b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/ClientRustModule.kt
index aa1f547dc4..988cac62f4 100644
--- a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/ClientRustModule.kt
+++ b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/ClientRustModule.kt
@@ -26,6 +26,7 @@ import software.amazon.smithy.rust.codegen.core.rustlang.writable
 import software.amazon.smithy.rust.codegen.core.smithy.ModuleDocProvider
 import software.amazon.smithy.rust.codegen.core.smithy.ModuleProvider
 import software.amazon.smithy.rust.codegen.core.smithy.ModuleProviderContext
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType
 import software.amazon.smithy.rust.codegen.core.smithy.contextName
 import software.amazon.smithy.rust.codegen.core.smithy.module
 import software.amazon.smithy.rust.codegen.core.smithy.traits.SyntheticInputTrait
@@ -122,7 +123,7 @@ class ClientModuleDocProvider(
                 operation call. For example, this can be used to add an additional HTTP header:
 
                 ```ignore
-                ## async fn wrapper() -> Result<(), $moduleUseName::Error> {
+                ## async fn wrapper() -> #{Result}<(), $moduleUseName::Error> {
                 ## let client: $moduleUseName::Client = unimplemented!();
                 use #{http}::header::{HeaderName, HeaderValue};
 
@@ -142,6 +143,7 @@ class ClientModuleDocProvider(
                 ## }
                 ```
                 """.trimIndent(),
+                *RuntimeType.preludeScope,
                 "http" to CargoDependency.Http.toDevDependency().toType(),
             )
         }
@@ -194,6 +196,10 @@ object ClientModuleProvider : ModuleProvider {
             operationModuleName,
             parent = ClientRustModule.Operation,
             documentationOverride = "Types for the `$contextName` operation.",
+            // TODO(https://github.com/tokio-rs/tokio/issues/5683): Uncomment the NoImplicitPrelude attribute once this Tokio issue is resolved
+            // // Disable the Rust prelude since every prelude type should be referenced with its
+            // // fully qualified name to avoid name collisions with the generated operation shapes.
+            // additionalAttributes = listOf(Attribute.NoImplicitPrelude)
         )
     }
 }
diff --git a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/customizations/IdempotencyTokenGenerator.kt b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/customizations/IdempotencyTokenGenerator.kt
index 8dd67bb9fe..24738036e1 100644
--- a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/customizations/IdempotencyTokenGenerator.kt
+++ b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/customizations/IdempotencyTokenGenerator.kt
@@ -8,9 +8,10 @@ package software.amazon.smithy.rust.codegen.client.smithy.customizations
 import software.amazon.smithy.model.shapes.OperationShape
 import software.amazon.smithy.model.traits.IdempotencyTokenTrait
 import software.amazon.smithy.rust.codegen.core.rustlang.Writable
-import software.amazon.smithy.rust.codegen.core.rustlang.rust
+import software.amazon.smithy.rust.codegen.core.rustlang.rustTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.writable
 import software.amazon.smithy.rust.codegen.core.smithy.CodegenContext
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.preludeScope
 import software.amazon.smithy.rust.codegen.core.smithy.customize.OperationCustomization
 import software.amazon.smithy.rust.codegen.core.smithy.customize.OperationSection
 import software.amazon.smithy.rust.codegen.core.util.findMemberWithTrait
@@ -28,12 +29,13 @@ class IdempotencyTokenGenerator(codegenContext: CodegenContext, operationShape:
         val memberName = symbolProvider.toMemberName(idempotencyTokenMember)
         return when (section) {
             is OperationSection.MutateInput -> writable {
-                rust(
+                rustTemplate(
                     """
                     if ${section.input}.$memberName.is_none() {
-                        ${section.input}.$memberName = Some(${section.config}.make_token.make_idempotency_token());
+                        ${section.input}.$memberName = #{Some}(${section.config}.make_token.make_idempotency_token());
                     }
                     """,
+                    *preludeScope,
                 )
             }
             else -> emptySection
diff --git a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/endpoint/EndpointsDecorator.kt b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/endpoint/EndpointsDecorator.kt
index bc101412af..0678a4db40 100644
--- a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/endpoint/EndpointsDecorator.kt
+++ b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/endpoint/EndpointsDecorator.kt
@@ -25,6 +25,7 @@ import software.amazon.smithy.rust.codegen.core.rustlang.Writable
 import software.amazon.smithy.rust.codegen.core.rustlang.rust
 import software.amazon.smithy.rust.codegen.core.rustlang.rustTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.writable
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType
 import software.amazon.smithy.rust.codegen.core.smithy.RustCrate
 import software.amazon.smithy.rust.codegen.core.smithy.customize.OperationCustomization
 import software.amazon.smithy.rust.codegen.core.smithy.customize.OperationSection
@@ -166,6 +167,7 @@ class EndpointsDecorator : ClientCodegenDecorator {
 
         override fun section(section: OperationSection): Writable {
             val codegenScope = arrayOf(
+                *RuntimeType.preludeScope,
                 "Params" to typesGenerator.paramsStruct(),
                 "ResolveEndpointError" to types.resolveEndpointError,
             )
@@ -174,10 +176,10 @@ class EndpointsDecorator : ClientCodegenDecorator {
                     rustTemplate(
                         """
                         let params_result = #{Params}::builder()#{builderFields:W}.build()
-                            .map_err(|err|#{ResolveEndpointError}::from_source("could not construct endpoint parameters", err));
+                            .map_err(|err| #{ResolveEndpointError}::from_source("could not construct endpoint parameters", err));
                         let (endpoint_result, params) = match params_result {
-                            Ok(params) => (${section.config}.endpoint_resolver.resolve_endpoint(&params), Some(params)),
-                            Err(e) => (Err(e), None)
+                            #{Ok}(params) => (${section.config}.endpoint_resolver.resolve_endpoint(&params), #{Some}(params)),
+                            #{Err}(e) => (#{Err}(e), #{None})
                         };
                         """,
                         "builderFields" to builderFields(typesGenerator.params, section),
@@ -188,7 +190,7 @@ class EndpointsDecorator : ClientCodegenDecorator {
                 is OperationSection.MutateRequest -> writable {
                     // insert the endpoint the bag
                     rustTemplate("${section.request}.properties_mut().insert(endpoint_result);")
-                    rustTemplate("""if let Some(params) = params { ${section.request}.properties_mut().insert(params); }""")
+                    rustTemplate("""if let #{Some}(params) = params { ${section.request}.properties_mut().insert(params); }""", *codegenScope)
                 }
 
                 else -> emptySection
@@ -199,8 +201,8 @@ class EndpointsDecorator : ClientCodegenDecorator {
             val node = this
             return writable {
                 when (node) {
-                    is StringNode -> rust("Some(${node.value.dq()}.to_string())")
-                    is BooleanNode -> rust("Some(${node.value})")
+                    is StringNode -> rustTemplate("#{Some}(${node.value.dq()}.to_string())", *RuntimeType.preludeScope)
+                    is BooleanNode -> rustTemplate("#{Some}(${node.value})", *RuntimeType.preludeScope)
                     else -> PANIC("unsupported default value: $node")
                 }
             }
diff --git a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/ClientEnumGenerator.kt b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/ClientEnumGenerator.kt
index d1b87591cb..64f6d9446b 100644
--- a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/ClientEnumGenerator.kt
+++ b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/ClientEnumGenerator.kt
@@ -17,6 +17,7 @@ import software.amazon.smithy.rust.codegen.core.rustlang.rustBlock
 import software.amazon.smithy.rust.codegen.core.rustlang.rustTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.writable
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.preludeScope
 import software.amazon.smithy.rust.codegen.core.smithy.generators.EnumGenerator
 import software.amazon.smithy.rust.codegen.core.smithy.generators.EnumGeneratorContext
 import software.amazon.smithy.rust.codegen.core.smithy.generators.EnumMemberModel
@@ -60,16 +61,17 @@ data class InfallibleEnumType(
     }
 
     override fun implFromStr(context: EnumGeneratorContext): Writable = writable {
-        rust(
+        rustTemplate(
             """
-            impl std::str::FromStr for ${context.enumName} {
-                type Err = std::convert::Infallible;
+            impl ::std::str::FromStr for ${context.enumName} {
+                type Err = ::std::convert::Infallible;
 
-                fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-                    Ok(${context.enumName}::from(s))
+                fn from_str(s: &str) -> #{Result}<Self, <Self as ::std::str::FromStr>::Err> {
+                    #{Ok}(${context.enumName}::from(s))
                 }
             }
             """,
+            *preludeScope,
         )
     }
 
@@ -98,7 +100,7 @@ data class InfallibleEnumType(
                 """.trimIndent(),
             )
             context.enumMeta.render(this)
-            rust("struct $UnknownVariantValue(pub(crate) String);")
+            rustTemplate("struct $UnknownVariantValue(pub(crate) #{String});", *preludeScope)
             rustBlock("impl $UnknownVariantValue") {
                 // The generated as_str is not pub as we need to prevent users from calling it on this opaque struct.
                 rustBlock("pub(crate) fn as_str(&self) -> &str") {
diff --git a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/NestedAccessorGenerator.kt b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/NestedAccessorGenerator.kt
index 2c752814be..138c7eb123 100644
--- a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/NestedAccessorGenerator.kt
+++ b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/NestedAccessorGenerator.kt
@@ -15,6 +15,7 @@ import software.amazon.smithy.rust.codegen.core.rustlang.rustTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.writable
 import software.amazon.smithy.rust.codegen.core.smithy.CodegenContext
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.preludeScope
 import software.amazon.smithy.rust.codegen.core.smithy.isOptional
 import software.amazon.smithy.rust.codegen.core.smithy.makeOptional
 import software.amazon.smithy.rust.codegen.core.smithy.mapRustType
@@ -72,17 +73,18 @@ class NestedAccessorGenerator(private val codegenContext: CodegenContext) {
                 ""
             }
             if (path.isEmpty()) {
-                rust("Some(input)")
+                rustTemplate("#{Some}(input)", *preludeScope)
             } else {
                 val head = path.first()
                 if (symbolProvider.toSymbol(head).isOptional()) {
-                    rust(
+                    rustTemplate(
                         """
                         let input = match ${ref}input.${symbolProvider.toMemberName(head)} {
-                            None => return None,
-                            Some(t) => t
+                            #{None} => return #{None},
+                            #{Some}(t) => t
                         };
                         """,
+                        *preludeScope,
                     )
                 } else {
                     rust("let input = input.${symbolProvider.toMemberName(head)};")
diff --git a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/PaginatorGenerator.kt b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/PaginatorGenerator.kt
index a20a33ecb0..d9709f5ff0 100644
--- a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/PaginatorGenerator.kt
+++ b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/PaginatorGenerator.kt
@@ -16,11 +16,11 @@ import software.amazon.smithy.rust.codegen.core.rustlang.RustModule
 import software.amazon.smithy.rust.codegen.core.rustlang.RustType
 import software.amazon.smithy.rust.codegen.core.rustlang.Writable
 import software.amazon.smithy.rust.codegen.core.rustlang.render
-import software.amazon.smithy.rust.codegen.core.rustlang.rust
 import software.amazon.smithy.rust.codegen.core.rustlang.rustTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.stripOuter
 import software.amazon.smithy.rust.codegen.core.rustlang.writable
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.preludeScope
 import software.amazon.smithy.rust.codegen.core.smithy.rustType
 import software.amazon.smithy.rust.codegen.core.util.PANIC
 import software.amazon.smithy.rust.codegen.core.util.findMemberWithTrait
@@ -86,6 +86,7 @@ class PaginatorGenerator private constructor(
     )
 
     private val codegenScope = arrayOf(
+        *preludeScope,
         "generics" to generics.decl,
         "bounds" to generics.bounds,
         "page_size_setter" to pageSizeSetter(),
@@ -158,31 +159,31 @@ class PaginatorGenerator private constructor(
                 /// Create the pagination stream
                 ///
                 /// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
-                pub fn send(self) -> impl #{Stream}<Item = std::result::Result<#{Output}, #{SdkError}<#{Error}>>> + Unpin
+                pub fn send(self) -> impl #{Stream}<Item = #{Result}<#{Output}, #{SdkError}<#{Error}>>> + #{Unpin}
                 #{send_bounds:W} {
                     // Move individual fields out of self for the borrow checker
                     let builder = self.builder;
                     let handle = self.handle;
-                    #{fn_stream}::FnStream::new(move |tx| Box::pin(async move {
+                    #{fn_stream}::FnStream::new(move |tx| #{Box}::pin(async move {
                         // Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
                         let mut input = match builder.build().map_err(#{SdkError}::construction_failure) {
-                            Ok(input) => input,
-                            Err(e) => { let _ = tx.send(Err(e)).await; return; }
+                            #{Ok}(input) => input,
+                            #{Err}(e) => { let _ = tx.send(#{Err}(e)).await; return; }
                         };
                         loop {
                             let op = match input.make_operation(&handle.conf)
                                 .await
                                 .map_err(#{SdkError}::construction_failure) {
-                                Ok(op) => op,
-                                Err(e) => {
-                                    let _ = tx.send(Err(e)).await;
+                                #{Ok}(op) => op,
+                                #{Err}(e) => {
+                                    let _ = tx.send(#{Err}(e)).await;
                                     return;
                                 }
                             };
                             let resp = handle.client.call(op).await;
                             // If the input member is None or it was an error
                             let done = match resp {
-                                Ok(ref resp) => {
+                                #{Ok}(ref resp) => {
                                     let new_token = #{output_token}(resp);
                                     let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
                                     if !is_empty && new_token == input.$inputTokenMember.as_ref() && self.stop_on_duplicate_token {
@@ -192,7 +193,7 @@ class PaginatorGenerator private constructor(
                                         is_empty
                                     }
                                 },
-                                Err(_) => true,
+                                #{Err}(_) => true,
                             };
                             if tx.send(resp).await.is_err() {
                                 // receiving end was dropped
@@ -263,7 +264,7 @@ class PaginatorGenerator private constructor(
                     /// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
                     ///
                     /// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
-                    pub fn send(self) -> impl #{Stream}<Item = std::result::Result<${itemType()}, #{SdkError}<#{Error}>>> + Unpin
+                    pub fn send(self) -> impl #{Stream}<Item = #{Result}<${itemType()}, #{SdkError}<#{Error}>>> + #{Unpin}
                     #{send_bounds:W} {
                         #{fn_stream}::TryFlatMap::new(self.0.send()).flat_map(|page| #{extract_items}(page).unwrap_or_default().into_iter())
                     }
@@ -284,16 +285,17 @@ class PaginatorGenerator private constructor(
             val memberName = symbolProvider.toMemberName(it)
             val pageSizeT =
                 symbolProvider.toSymbol(it).rustType().stripOuter<RustType.Option>().render(true)
-            rust(
+            rustTemplate(
                 """
                 /// Set the page size
                 ///
                 /// _Note: this method will override any previously set value for `$memberName`_
                 pub fn page_size(mut self, limit: $pageSizeT) -> Self {
-                    self.builder.$memberName = Some(limit);
+                    self.builder.$memberName = #{Some}(limit);
                     self
                 }
                 """,
+                *preludeScope,
             )
         }
     }
diff --git a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/ServiceRuntimePluginGenerator.kt b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/ServiceRuntimePluginGenerator.kt
index 8a9ea8f765..d00af9b66b 100644
--- a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/ServiceRuntimePluginGenerator.kt
+++ b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/ServiceRuntimePluginGenerator.kt
@@ -14,6 +14,7 @@ import software.amazon.smithy.rust.codegen.core.rustlang.rustTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.writable
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeConfig
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.preludeScope
 import software.amazon.smithy.rust.codegen.core.smithy.customize.NamedCustomization
 import software.amazon.smithy.rust.codegen.core.smithy.customize.Section
 import software.amazon.smithy.rust.codegen.core.smithy.customize.writeCustomizations
@@ -65,6 +66,8 @@ class ServiceRuntimePluginGenerator(
         val runtime = RuntimeType.smithyRuntime(rc)
         val runtimeApi = RuntimeType.smithyRuntimeApi(rc)
         arrayOf(
+            *preludeScope,
+            "Arc" to RuntimeType.Arc,
             "AnonymousIdentityResolver" to runtimeApi.resolve("client::identity::AnonymousIdentityResolver"),
             "BoxError" to runtimeApi.resolve("client::runtime_plugin::BoxError"),
             "ConfigBag" to runtimeApi.resolve("config_bag::ConfigBag"),
@@ -90,17 +93,17 @@ class ServiceRuntimePluginGenerator(
             """
             ##[derive(Debug)]
             pub(crate) struct ServiceRuntimePlugin {
-                handle: std::sync::Arc<crate::client::Handle>,
+                handle: #{Arc}<crate::client::Handle>,
             }
 
             impl ServiceRuntimePlugin {
-                pub fn new(handle: std::sync::Arc<crate::client::Handle>) -> Self {
+                pub fn new(handle: #{Arc}<crate::client::Handle>) -> Self {
                     Self { handle }
                 }
             }
 
             impl #{RuntimePlugin} for ServiceRuntimePlugin {
-                fn configure(&self, cfg: &mut #{ConfigBag}, _interceptors: &mut #{InterceptorRegistrar}) -> Result<(), #{BoxError}> {
+                fn configure(&self, cfg: &mut #{ConfigBag}, _interceptors: &mut #{InterceptorRegistrar}) -> #{Result}<(), #{BoxError}> {
                     use #{ConfigBagAccessors};
 
                     // HACK: Put the handle into the config bag to work around config not being fully implemented yet
@@ -112,7 +115,7 @@ class ServiceRuntimePluginGenerator(
                     cfg.set_http_auth_schemes(http_auth_schemes);
 
                     // Set an empty auth option resolver to be overridden by operations that need auth.
-                    cfg.set_auth_option_resolver(#{StaticAuthOptionResolver}::new(Vec::new()));
+                    cfg.set_auth_option_resolver(#{StaticAuthOptionResolver}::new(#{Vec}::new()));
 
                     let endpoint_resolver = #{DefaultEndpointResolver}::<#{Params}>::new(
                         #{SharedEndpointResolver}::from(self.handle.conf.endpoint_resolver()));
@@ -123,9 +126,9 @@ class ServiceRuntimePluginGenerator(
 
                     // TODO(RuntimePlugins): Replace this with the correct long-term solution
                     let sleep_impl = self.handle.conf.sleep_impl();
-                    let connection: Box<dyn #{Connection}> = self.handle.conf.http_connector()
+                    let connection: #{Box}<dyn #{Connection}> = self.handle.conf.http_connector()
                             .and_then(move |c| c.connector(&#{ConnectorSettings}::default(), sleep_impl))
-                            .map(|c| Box::new(#{DynConnectorAdapter}::new(c)) as _)
+                            .map(|c| #{Box}::new(#{DynConnectorAdapter}::new(c)) as _)
                             .expect("connection set");
                     cfg.set_connection(connection);
 
diff --git a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/client/CustomizableOperationGenerator.kt b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/client/CustomizableOperationGenerator.kt
index a45bad43d0..d16d927d7f 100644
--- a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/client/CustomizableOperationGenerator.kt
+++ b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/client/CustomizableOperationGenerator.kt
@@ -14,6 +14,7 @@ import software.amazon.smithy.rust.codegen.core.rustlang.RustWriter
 import software.amazon.smithy.rust.codegen.core.rustlang.rustTemplate
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeConfig
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.preludeScope
 import software.amazon.smithy.rust.codegen.core.smithy.RustCrate
 
 /**
@@ -54,33 +55,27 @@ class CustomizableOperationGenerator(
         val combinedGenerics = operationGenerics + handleGenerics
 
         val codegenScope = arrayOf(
+            *preludeScope,
+            "Arc" to RuntimeType.Arc,
+            "Infallible" to RuntimeType.stdConvert.resolve("Infallible"),
             // SDK Types
-            "http_result" to smithyHttp.resolve("result"),
-            "http_body" to smithyHttp.resolve("body"),
             "HttpRequest" to RuntimeType.HttpRequest,
             "handle_generics_decl" to handleGenerics.declaration(),
             "handle_generics_bounds" to handleGenerics.bounds(),
             "operation_generics_decl" to operationGenerics.declaration(),
             "combined_generics_decl" to combinedGenerics.declaration(),
             "customize_module" to ClientRustModule.Client.customize,
+            "SdkBody" to RuntimeType.sdkBody(runtimeConfig),
         )
 
         writer.rustTemplate(
             """
-            use crate::client::Handle;
-
-            use #{http_body}::SdkBody;
-            use #{http_result}::SdkError;
-
-            use std::convert::Infallible;
-            use std::sync::Arc;
-
             /// A wrapper type for [`Operation`](aws_smithy_http::operation::Operation)s that allows for
             /// customization of the operation before it is sent. A `CustomizableOperation` may be sent
             /// by calling its [`.send()`][#{customize_module}::CustomizableOperation::send] method.
             ##[derive(Debug)]
             pub struct CustomizableOperation#{combined_generics_decl:W} {
-                pub(crate) handle: Arc<Handle#{handle_generics_decl:W}>,
+                pub(crate) handle: #{Arc}<crate::client::Handle#{handle_generics_decl:W}>,
                 pub(crate) operation: Operation#{operation_generics_decl:W},
             }
 
@@ -91,19 +86,19 @@ class CustomizableOperationGenerator(
                 /// Allows for customizing the operation's request
                 pub fn map_request<E>(
                     mut self,
-                    f: impl FnOnce(#{HttpRequest}<SdkBody>) -> Result<#{HttpRequest}<SdkBody>, E>,
-                ) -> Result<Self, E> {
+                    f: impl #{FnOnce}(#{HttpRequest}<#{SdkBody}>) -> #{Result}<#{HttpRequest}<#{SdkBody}>, E>,
+                ) -> #{Result}<Self, E> {
                     let (request, response) = self.operation.into_request_response();
                     let request = request.augment(|req, _props| f(req))?;
                     self.operation = Operation::from_parts(request, response);
-                    Ok(self)
+                    #{Ok}(self)
                 }
 
                 /// Convenience for `map_request` where infallible direct mutation of request is acceptable
-                pub fn mutate_request(self, f: impl FnOnce(&mut #{HttpRequest}<SdkBody>)) -> Self {
+                pub fn mutate_request(self, f: impl #{FnOnce}(&mut #{HttpRequest}<#{SdkBody}>)) -> Self {
                     self.map_request(|mut req| {
                         f(&mut req);
-                        Result::<_, Infallible>::Ok(req)
+                        #{Result}::<_, #{Infallible}>::Ok(req)
                     })
                     .expect("infallible")
                 }
@@ -111,19 +106,19 @@ class CustomizableOperationGenerator(
                 /// Allows for customizing the entire operation
                 pub fn map_operation<E>(
                     mut self,
-                    f: impl FnOnce(Operation#{operation_generics_decl:W}) -> Result<Operation#{operation_generics_decl:W}, E>,
-                ) -> Result<Self, E> {
+                    f: impl #{FnOnce}(Operation#{operation_generics_decl:W}) -> #{Result}<Operation#{operation_generics_decl:W}, E>,
+                ) -> #{Result}<Self, E> {
                     self.operation = f(self.operation)?;
-                    Ok(self)
+                    #{Ok}(self)
                 }
 
                 /// Direct access to read the HTTP request
-                pub fn request(&self) -> &#{HttpRequest}<SdkBody> {
+                pub fn request(&self) -> &#{HttpRequest}<#{SdkBody}> {
                     self.operation.request()
                 }
 
                 /// Direct access to mutate the HTTP request
-                pub fn request_mut(&mut self) -> &mut #{HttpRequest}<SdkBody> {
+                pub fn request_mut(&mut self) -> &mut #{HttpRequest}<#{SdkBody}> {
                     self.operation.request_mut()
                 }
             }
@@ -142,6 +137,7 @@ fun renderCustomizableOperationSend(runtimeConfig: RuntimeConfig, generics: Flue
     val combinedGenerics = operationGenerics + handleGenerics
 
     val codegenScope = arrayOf(
+        *preludeScope,
         "combined_generics_decl" to combinedGenerics.declaration(),
         "handle_generics_bounds" to handleGenerics.bounds(),
         "ParseHttpResponse" to smithyHttp.resolve("response::ParseHttpResponse"),
@@ -160,13 +156,13 @@ fun renderCustomizableOperationSend(runtimeConfig: RuntimeConfig, generics: Flue
                 #{handle_generics_bounds:W}
             {
                 /// Sends this operation's request
-                pub async fn send<T, E>(self) -> Result<T, SdkError<E>>
+                pub async fn send<T, E>(self) -> #{Result}<T, #{SdkError}<E>>
                 where
-                    E: std::error::Error + Send + Sync + 'static,
-                    O: #{ParseHttpResponse}<Output = Result<T, E>> + Send + Sync + Clone + 'static,
-                    Retry: Send + Sync + Clone,
-                    Retry: #{ClassifyRetry}<#{SdkSuccess}<T>, #{SdkError}<E>> + Send + Sync + Clone,
-                    <R as #{NewRequestPolicy}>::Policy: #{SmithyRetryPolicy}<O, T, E, Retry> + Clone,
+                    E: std::error::Error + #{Send} + #{Sync} + 'static,
+                    O: #{ParseHttpResponse}<Output = #{Result}<T, E>> + #{Send} + #{Sync} + #{Clone} + 'static,
+                    Retry: #{Send} + #{Sync} + #{Clone},
+                    Retry: #{ClassifyRetry}<#{SdkSuccess}<T>, #{SdkError}<E>> + #{Send} + #{Sync} + #{Clone},
+                    <R as #{NewRequestPolicy}>::Policy: #{SmithyRetryPolicy}<O, T, E, Retry> + #{Clone},
                 {
                     self.handle.client.call(self.operation).await
                 }
@@ -182,11 +178,11 @@ fun renderCustomizableOperationSend(runtimeConfig: RuntimeConfig, generics: Flue
                 #{handle_generics_bounds:W}
             {
                 /// Sends this operation's request
-                pub async fn send<T, E>(self) -> Result<T, SdkError<E>>
+                pub async fn send<T, E>(self) -> #{Result}<T, #{SdkError}<E>>
                 where
-                    E: std::error::Error + Send + Sync + 'static,
-                    O: #{ParseHttpResponse}<Output = Result<T, E>> + Send + Sync + Clone + 'static,
-                    Retry: #{ClassifyRetry}<#{SdkSuccess}<T>, #{SdkError}<E>> + Send + Sync + Clone,
+                    E: std::error::Error + #{Send} + #{Sync} + 'static,
+                    O: #{ParseHttpResponse}<Output = #{Result}<T, E>> + #{Send} + #{Sync} + #{Clone} + 'static,
+                    Retry: #{ClassifyRetry}<#{SdkSuccess}<T>, #{SdkError}<E>> + #{Send} + #{Sync} + #{Clone},
                 {
                     self.handle.client.call(self.operation).await
                 }
diff --git a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/client/FluentClientGenerator.kt b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/client/FluentClientGenerator.kt
index 551a33a14a..10a4f0c02f 100644
--- a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/client/FluentClientGenerator.kt
+++ b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/client/FluentClientGenerator.kt
@@ -41,6 +41,7 @@ import software.amazon.smithy.rust.codegen.core.rustlang.stripOuter
 import software.amazon.smithy.rust.codegen.core.rustlang.withBlockTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.writable
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.preludeScope
 import software.amazon.smithy.rust.codegen.core.smithy.RustCrate
 import software.amazon.smithy.rust.codegen.core.smithy.RustSymbolProvider
 import software.amazon.smithy.rust.codegen.core.smithy.customize.writeCustomizations
@@ -112,12 +113,12 @@ class FluentClientGenerator(
                 }
 
                 #{client_docs:W}
-                ##[derive(std::fmt::Debug)]
+                ##[derive(::std::fmt::Debug)]
                 pub struct Client#{generics_decl:W} {
-                    handle: std::sync::Arc<Handle${generics.inst}>
+                    handle: #{Arc}<Handle${generics.inst}>
                 }
 
-                impl${generics.inst} std::clone::Clone for Client${generics.inst} {
+                impl${generics.inst} #{Clone} for Client${generics.inst} {
                     fn clone(&self) -> Self {
                         Self { handle: self.handle.clone() }
                     }
@@ -133,7 +134,7 @@ class FluentClientGenerator(
                     /// Creates a client with the given service configuration.
                     pub fn with_config(client: #{client}::Client#{smithy_inst:W}, conf: crate::Config) -> Self {
                         Self {
-                            handle: std::sync::Arc::new(Handle {
+                            handle: #{Arc}::new(Handle {
                                 client,
                                 conf,
                             })
@@ -146,6 +147,8 @@ class FluentClientGenerator(
                     }
                 }
                 """,
+                *preludeScope,
+                "Arc" to RuntimeType.Arc,
                 "generics_decl" to generics.decl,
                 "smithy_inst" to generics.smithyInst,
                 "client" to RuntimeType.smithyClient(runtimeConfig),
@@ -249,14 +252,15 @@ class FluentClientGenerator(
         ) {
             rustTemplate(
                 """
-                handle: std::sync::Arc<crate::client::Handle${generics.inst}>,
+                handle: #{Arc}<crate::client::Handle${generics.inst}>,
                 inner: #{Inner},
                 """,
                 "Inner" to symbolProvider.symbolForBuilder(input),
+                "Arc" to RuntimeType.Arc,
                 "generics" to generics.decl,
             )
             if (smithyRuntimeMode.generateOrchestrator) {
-                rust("config_override: std::option::Option<crate::config::Builder>,")
+                rustTemplate("config_override: #{Option}<crate::config::Builder>,", *preludeScope)
             }
         }
 
@@ -270,21 +274,23 @@ class FluentClientGenerator(
 
             rust("/// Creates a new `${operationSymbol.name}`.")
             withBlockTemplate(
-                "pub(crate) fn new(handle: std::sync::Arc<crate::client::Handle${generics.inst}>) -> Self {",
+                "pub(crate) fn new(handle: #{Arc}<crate::client::Handle${generics.inst}>) -> Self {",
                 "}",
+                "Arc" to RuntimeType.Arc,
                 "generics" to generics.decl,
             ) {
                 withBlockTemplate(
                     "Self {",
                     "}",
                 ) {
-                    rust("handle, inner: Default::default(),")
+                    rustTemplate("handle, inner: #{Default}::default(),", *preludeScope)
                     if (smithyRuntimeMode.generateOrchestrator) {
-                        rust("config_override: None,")
+                        rustTemplate("config_override: #{None},", *preludeScope)
                     }
                 }
             }
             val middlewareScope = arrayOf(
+                *preludeScope,
                 "CustomizableOperation" to ClientRustModule.Client.customize.toType()
                     .resolve("CustomizableOperation"),
                 "ClassifyRetry" to RuntimeType.classifyRetry(runtimeConfig),
@@ -303,7 +309,7 @@ class FluentClientGenerator(
                 """
                 /// Consume this builder, creating a customizable operation that can be modified before being
                 /// sent. The operation's inner [http::Request] can be modified as well.
-                pub async fn customize(self) -> std::result::Result<
+                pub async fn customize(self) -> #{Result}<
                     #{CustomizableOperation}#{customizable_op_type_params:W},
                     #{SdkError}<#{OperationError}>
                 > #{send_bounds:W} {
@@ -312,12 +318,12 @@ class FluentClientGenerator(
                         .make_operation(&handle.conf)
                         .await
                         .map_err(#{SdkError}::construction_failure)?;
-                    Ok(#{CustomizableOperation} { handle, operation })
+                    #{Ok}(#{CustomizableOperation} { handle, operation })
                 }
 
                 // This function will go away in the near future. Do not rely on it.
                 ##[doc(hidden)]
-                pub async fn send_middleware(self) -> std::result::Result<#{OperationOutput}, #{SdkError}<#{OperationError}>>
+                pub async fn send_middleware(self) -> #{Result}<#{OperationOutput}, #{SdkError}<#{OperationError}>>
                 #{send_bounds:W} {
                     let op = self.inner.build().map_err(#{SdkError}::construction_failure)?
                         .make_operation(&self.handle.conf)
@@ -339,7 +345,7 @@ class FluentClientGenerator(
                     /// By default, any retryable failures will be retried twice. Retry behavior
                     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
                     /// set when configuring the client.
-                    pub async fn send(self) -> std::result::Result<#{OperationOutput}, #{SdkError}<#{OperationError}>>
+                    pub async fn send(self) -> #{Result}<#{OperationOutput}, #{SdkError}<#{OperationError}>>
                     #{send_bounds:W} {
                         self.send_middleware().await
                     }
@@ -350,6 +356,7 @@ class FluentClientGenerator(
 
             if (smithyRuntimeMode.generateOrchestrator) {
                 val orchestratorScope = arrayOf(
+                    *preludeScope,
                     "HttpResponse" to RuntimeType.smithyRuntimeApi(runtimeConfig)
                         .resolve("client::orchestrator::HttpResponse"),
                     "OperationError" to errorType,
@@ -365,14 +372,14 @@ class FluentClientGenerator(
                 rustTemplate(
                     """
                     ##[doc(hidden)]
-                    pub async fn send_orchestrator(self) -> std::result::Result<#{OperationOutput}, #{SdkError}<#{OperationError}, #{HttpResponse}>> {
-                        self.send_orchestrator_with_plugin(Option::<Box<dyn #{RuntimePlugin} + Send + Sync>>::None).await
+                    pub async fn send_orchestrator(self) -> #{Result}<#{OperationOutput}, #{SdkError}<#{OperationError}, #{HttpResponse}>> {
+                        self.send_orchestrator_with_plugin(#{Option}::<Box<dyn #{RuntimePlugin} + #{Send} + #{Sync}>>::None).await
                     }
 
                     ##[doc(hidden)]
                     // TODO(enableNewSmithyRuntime): Delete when unused
                     /// Equivalent to [`Self::send_orchestrator`] but adds a final runtime plugin to shim missing behavior
-                    pub async fn send_orchestrator_with_plugin(self, final_plugin: Option<impl #{RuntimePlugin} + Send + Sync + 'static>) -> std::result::Result<#{OperationOutput}, #{SdkError}<#{OperationError}, #{HttpResponse}>> {
+                    pub async fn send_orchestrator_with_plugin(self, final_plugin: #{Option}<impl #{RuntimePlugin} + #{Send} + #{Sync} + 'static>) -> #{Result}<#{OperationOutput}, #{SdkError}<#{OperationError}, #{HttpResponse}>> {
                         let mut runtime_plugins = #{RuntimePlugins}::new()
                             .with_client_plugin(crate::config::ServiceRuntimePlugin::new(self.handle.clone()));
                         if let Some(config_override) = self.config_override {
@@ -393,7 +400,7 @@ class FluentClientGenerator(
                                         .unwrap()
                                 })
                             })?;
-                        Ok(#{TypedBox}::<#{OperationOutput}>::assume_from(output).expect("correct output type").unwrap())
+                        #{Ok}(#{TypedBox}::<#{OperationOutput}>::assume_from(output).expect("correct output type").unwrap())
                     }
                     """,
                     *orchestratorScope,
@@ -409,7 +416,7 @@ class FluentClientGenerator(
                         /// By default, any retryable failures will be retried twice. Retry behavior
                         /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
                         /// set when configuring the client.
-                        pub async fn send(self) -> std::result::Result<#{OperationOutput}, #{SdkError}<#{OperationError}, #{HttpResponse}>> {
+                        pub async fn send(self) -> #{Result}<#{OperationOutput}, #{SdkError}<#{OperationError}, #{HttpResponse}>> {
                             self.send_orchestrator().await
                         }
                         """,
diff --git a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/error/OperationErrorGenerator.kt b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/error/OperationErrorGenerator.kt
index 26d926a78d..8e17d5bd9d 100644
--- a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/error/OperationErrorGenerator.kt
+++ b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/error/OperationErrorGenerator.kt
@@ -22,10 +22,12 @@ import software.amazon.smithy.rust.codegen.core.rustlang.docs
 import software.amazon.smithy.rust.codegen.core.rustlang.documentShape
 import software.amazon.smithy.rust.codegen.core.rustlang.rust
 import software.amazon.smithy.rust.codegen.core.rustlang.rustBlock
+import software.amazon.smithy.rust.codegen.core.rustlang.rustBlockTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.rustTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.writable
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.errorMetadata
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.preludeScope
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.unhandledError
 import software.amazon.smithy.rust.codegen.core.smithy.RustSymbolProvider
 import software.amazon.smithy.rust.codegen.core.smithy.customize.Section
@@ -107,14 +109,16 @@ class OperationErrorGenerator(
             )
         }
         writer.rustBlock("impl #T for ${errorSymbol.name}", createUnhandledError) {
-            rustBlock(
+            rustBlockTemplate(
                 """
                 fn create_unhandled_error(
-                    source: Box<dyn std::error::Error + Send + Sync + 'static>,
-                    meta: std::option::Option<#T>
+                    source: #{Box}<dyn #{StdError} + #{Send} + #{Sync} + 'static>,
+                    meta: #{Option}<#{ErrorMeta}>
                 ) -> Self
                 """,
-                errorMetadata,
+                *preludeScope,
+                "StdError" to RuntimeType.StdError,
+                "ErrorMeta" to errorMetadata,
             ) {
                 rust(
                     """
@@ -129,7 +133,7 @@ class OperationErrorGenerator(
             }
         }
         writer.rustBlock("impl #T for ${errorSymbol.name}", RuntimeType.Display) {
-            rustBlock("fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result") {
+            rustBlock("fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result") {
                 delegateToVariants(errors) {
                     writable { rust("_inner.fmt(f)") }
                 }
@@ -152,21 +156,28 @@ class OperationErrorGenerator(
             "impl #T for ${errorSymbol.name}",
             RuntimeType.provideErrorKind(symbolProvider.config.runtimeConfig),
         ) {
-            rustBlock("fn code(&self) -> std::option::Option<&str>") {
+            rustBlockTemplate("fn code(&self) -> #{Option}<&str>", *preludeScope) {
                 rust("#T::code(self)", RuntimeType.provideErrorMetadataTrait(runtimeConfig))
             }
 
-            rustBlock("fn retryable_error_kind(&self) -> std::option::Option<#T>", retryErrorKindT) {
+            rustBlockTemplate(
+                "fn retryable_error_kind(&self) -> #{Option}<#{ErrorKind}>",
+                "ErrorKind" to retryErrorKindT,
+                *preludeScope,
+            ) {
                 val retryableVariants = errors.filter { it.hasTrait<RetryableTrait>() }
                 if (retryableVariants.isEmpty()) {
-                    rust("None")
+                    rustTemplate("#{None}", *preludeScope)
                 } else {
                     rustBlock("match self") {
                         retryableVariants.forEach {
                             val errorVariantSymbol = symbolProvider.toSymbol(it)
-                            rust("Self::${errorVariantSymbol.name}(inner) => Some(inner.retryable_error_kind()),")
+                            rustTemplate(
+                                "Self::${errorVariantSymbol.name}(inner) => #{Some}(inner.retryable_error_kind()),",
+                                *preludeScope,
+                            )
                         }
-                        rust("_ => None")
+                        rustTemplate("_ => #{None}", *preludeScope)
                     }
                 }
             }
@@ -176,7 +187,7 @@ class OperationErrorGenerator(
             writer.rustTemplate(
                 """
                 /// Creates the `${errorSymbol.name}::Unhandled` variant from any error type.
-                pub fn unhandled(err: impl Into<Box<dyn #{std_error} + Send + Sync + 'static>>) -> Self {
+                pub fn unhandled(err: impl #{Into}<#{Box}<dyn #{StdError} + #{Send} + #{Sync} + 'static>>) -> Self {
                     Self::Unhandled(#{Unhandled}::builder().source(err).build())
                 }
 
@@ -185,8 +196,9 @@ class OperationErrorGenerator(
                     Self::Unhandled(#{Unhandled}::builder().source(err.clone()).meta(err).build())
                 }
                 """,
+                *preludeScope,
                 "error_metadata" to errorMetadata,
-                "std_error" to RuntimeType.StdError,
+                "StdError" to RuntimeType.StdError,
                 "Unhandled" to unhandledError(runtimeConfig),
             )
             writer.docs(
@@ -216,10 +228,14 @@ class OperationErrorGenerator(
         }
 
         writer.rustBlock("impl #T for ${errorSymbol.name}", RuntimeType.StdError) {
-            rustBlock("fn source(&self) -> std::option::Option<&(dyn #T + 'static)>", RuntimeType.StdError) {
+            rustBlockTemplate(
+                "fn source(&self) -> #{Option}<&(dyn #{StdError} + 'static)>",
+                *preludeScope,
+                "StdError" to RuntimeType.StdError,
+            ) {
                 delegateToVariants(errors) {
                     writable {
-                        rust("Some(_inner)")
+                        rustTemplate("#{Some}(_inner)", *preludeScope)
                     }
                 }
             }
diff --git a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/http/RequestBindingGenerator.kt b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/http/RequestBindingGenerator.kt
index 148a09d4bd..0a4e5fb09b 100644
--- a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/http/RequestBindingGenerator.kt
+++ b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/http/RequestBindingGenerator.kt
@@ -23,6 +23,7 @@ import software.amazon.smithy.rust.codegen.core.rustlang.rustBlockTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.rustTemplate
 import software.amazon.smithy.rust.codegen.core.smithy.CodegenContext
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.preludeScope
 import software.amazon.smithy.rust.codegen.core.smithy.generators.OperationBuildError
 import software.amazon.smithy.rust.codegen.core.smithy.generators.http.HttpBindingGenerator
 import software.amazon.smithy.rust.codegen.core.smithy.generators.operationBuildError
@@ -71,6 +72,7 @@ class RequestBindingGenerator(
     private val encoder = RuntimeType.smithyTypes(runtimeConfig).resolve("primitive::Encoder")
 
     private val codegenScope = arrayOf(
+        *preludeScope,
         "BuildError" to runtimeConfig.operationBuildError(),
         "HttpRequestBuilder" to RuntimeType.HttpRequestBuilder,
         "Input" to symbolProvider.toSymbol(inputShape),
@@ -90,11 +92,11 @@ class RequestBindingGenerator(
             fn update_http_builder(
                 input: &#{Input},
                 builder: #{HttpRequestBuilder}
-            ) -> std::result::Result<#{HttpRequestBuilder}, #{BuildError}>
+            ) -> #{Result}<#{HttpRequestBuilder}, #{BuildError}>
             """,
             *codegenScope,
         ) {
-            write("let mut uri = String::new();")
+            rustTemplate("let mut uri = #{String}::new();", *preludeScope)
             write("uri_base(input, &mut uri)?;")
             if (hasQuery) {
                 write("uri_query(input, &mut uri)?;")
@@ -107,7 +109,7 @@ class RequestBindingGenerator(
                     addHeadersFn,
                 )
             }
-            write("Ok(builder.method(${httpTrait.method.dq()}).uri(uri))")
+            rustTemplate("#{Ok}(builder.method(${httpTrait.method.dq()}).uri(uri))", *preludeScope)
         }
     }
 
@@ -126,7 +128,7 @@ class RequestBindingGenerator(
         }
         val combinedArgs = listOf(formatString, *args.toTypedArray())
         writer.rustBlockTemplate(
-            "fn uri_base(_input: &#{Input}, output: &mut String) -> std::result::Result<(), #{BuildError}>",
+            "fn uri_base(_input: &#{Input}, output: &mut #{String}) -> #{Result}<(), #{BuildError}>",
             *codegenScope,
         ) {
             rust("use #T as _;", RuntimeType.stdFmt.resolve("Write"))
@@ -134,8 +136,8 @@ class RequestBindingGenerator(
                 val member = inputShape.expectMember(label.content)
                 serializeLabel(member, label, local(member))
             }
-            rust("""write!(output, ${combinedArgs.joinToString(", ")}).expect("formatting should succeed");""")
-            rust("Ok(())")
+            rust("""::std::write!(output, ${combinedArgs.joinToString(", ")}).expect("formatting should succeed");""")
+            rustTemplate("#{Ok}(())", *codegenScope)
         }
     }
 
@@ -165,7 +167,7 @@ class RequestBindingGenerator(
         }
         val preloadedParams = literalParams.keys + dynamicParams.map { it.locationName }
         writer.rustBlockTemplate(
-            "fn uri_query(_input: &#{Input}, mut output: &mut String) -> Result<(), #{BuildError}>",
+            "fn uri_query(_input: &#{Input}, mut output: &mut #{String}) -> #{Result}<(), #{BuildError}>",
             *codegenScope,
         ) {
             write("let mut query = #T::new(output);", RuntimeType.queryFormat(runtimeConfig, "Writer"))
@@ -212,6 +214,7 @@ class RequestBindingGenerator(
 
                 if (memberShape.isRequired) {
                     val codegenScope = arrayOf(
+                        *preludeScope,
                         "BuildError" to OperationBuildError(runtimeConfig).missingField(
                             memberName,
                             "cannot be empty or unset",
@@ -229,7 +232,7 @@ class RequestBindingGenerator(
                     // Strings that aren't enums must be checked to see if they're empty
                     if (target.isStringShape && !target.hasTrait<EnumTrait>()) {
                         rustBlock("if $derefName.is_empty()") {
-                            rustTemplate("return Err(#{BuildError:W});", *codegenScope)
+                            rustTemplate("return #{Err}(#{BuildError:W});", *codegenScope)
                         }
                     }
 
@@ -241,7 +244,7 @@ class RequestBindingGenerator(
                     }
                 }
             }
-            writer.rust("Ok(())")
+            writer.rustTemplate("#{Ok}(())", *codegenScope)
         }
         return true
     }
@@ -329,9 +332,10 @@ class RequestBindingGenerator(
         rustTemplate(
             """
             if $outputVar.is_empty() {
-                return Err(#{buildError:W})
+                return #{Err}(#{buildError:W})
             }
             """,
+            *preludeScope,
             "buildError" to buildError,
         )
     }
diff --git a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/protocol/MakeOperationGenerator.kt b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/protocol/MakeOperationGenerator.kt
index 5d206d47e8..8f2dcda292 100644
--- a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/protocol/MakeOperationGenerator.kt
+++ b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/protocol/MakeOperationGenerator.kt
@@ -20,6 +20,7 @@ import software.amazon.smithy.rust.codegen.core.rustlang.withBlock
 import software.amazon.smithy.rust.codegen.core.rustlang.withBlockTemplate
 import software.amazon.smithy.rust.codegen.core.smithy.CodegenContext
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.preludeScope
 import software.amazon.smithy.rust.codegen.core.smithy.customize.OperationCustomization
 import software.amazon.smithy.rust.codegen.core.smithy.customize.OperationSection
 import software.amazon.smithy.rust.codegen.core.smithy.customize.writeCustomizations
@@ -56,13 +57,15 @@ open class MakeOperationGenerator(
             ?: codegenContext.serviceShape.id.getName(codegenContext.serviceShape)
 
     private val codegenScope = arrayOf(
+        *preludeScope,
         "config" to ClientRustModule.Config,
         "header_util" to RuntimeType.smithyHttp(runtimeConfig).resolve("header"),
         "http" to RuntimeType.Http,
+        "operation" to RuntimeType.operationModule(runtimeConfig),
         "HttpRequestBuilder" to RuntimeType.HttpRequestBuilder,
         "OpBuildError" to runtimeConfig.operationBuildError(),
-        "operation" to RuntimeType.operationModule(runtimeConfig),
         "SdkBody" to RuntimeType.sdkBody(runtimeConfig),
+        "SharedPropertyBag" to RuntimeType.smithyHttp(runtimeConfig).resolve("property_bag::SharedPropertyBag"),
     )
 
     fun generateMakeOperation(
@@ -73,7 +76,7 @@ open class MakeOperationGenerator(
         val operationName = symbolProvider.toSymbol(shape).name
         val baseReturnType = buildOperationType(implBlockWriter, shape, customizations)
         val returnType =
-            "std::result::Result<$baseReturnType, ${implBlockWriter.format(runtimeConfig.operationBuildError())}>"
+            "#{Result}<$baseReturnType, ${implBlockWriter.format(runtimeConfig.operationBuildError())}>"
         val outputSymbol = symbolProvider.toSymbol(shape)
 
         val takesOwnership = bodyGenerator.payloadMetadata(shape).takesOwnership
@@ -99,7 +102,7 @@ open class MakeOperationGenerator(
             withBlock("let mut request = {", "};") {
                 createHttpRequest(this, shape)
             }
-            rust("let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();")
+            rustTemplate("let mut properties = #{SharedPropertyBag}::new();", *codegenScope)
 
             // When the payload is a `ByteStream`, `into_inner()` already returns an `SdkBody`, so we mute this
             // Clippy warning to make the codegen a little simpler in that case.
@@ -116,7 +119,7 @@ open class MakeOperationGenerator(
             if (includeDefaultPayloadHeaders && needsContentLength(shape)) {
                 rustTemplate(
                     """
-                    if let Some(content_length) = body.content_length() {
+                    if let #{Some}(content_length) = body.content_length() {
                         request = #{header_util}::set_request_header_if_absent(request, #{http}::header::CONTENT_LENGTH, content_length);
                     }
                     """,
@@ -140,7 +143,7 @@ open class MakeOperationGenerator(
                 "OperationType" to symbolProvider.toSymbol(shape),
             )
             writeCustomizations(customizations, OperationSection.FinalizeOperation(customizations, "op", "_config"))
-            rust("Ok(op)")
+            rustTemplate("#{Ok}(op)", *codegenScope)
         }
     }
 
diff --git a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/protocol/ProtocolTestGenerator.kt b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/protocol/ProtocolTestGenerator.kt
index 5a1c4993b0..cafefc1179 100644
--- a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/protocol/ProtocolTestGenerator.kt
+++ b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/protocol/ProtocolTestGenerator.kt
@@ -351,7 +351,7 @@ class ProtocolTestGenerator(
             rustWriter.rustTemplate(
                 """
                 // No body
-                #{AssertEq}(std::str::from_utf8(body).unwrap(), "");
+                #{AssertEq}(::std::str::from_utf8(body).unwrap(), "");
                 """,
                 *codegenScope,
             )
diff --git a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/protocols/HttpBoundProtocolGenerator.kt b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/protocols/HttpBoundProtocolGenerator.kt
index 83578b2ac5..ae83e78cfe 100644
--- a/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/protocols/HttpBoundProtocolGenerator.kt
+++ b/codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/protocols/HttpBoundProtocolGenerator.kt
@@ -19,6 +19,7 @@ import software.amazon.smithy.rust.codegen.core.rustlang.rustBlockTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.rustTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.writable
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.preludeScope
 import software.amazon.smithy.rust.codegen.core.smithy.customize.OperationCustomization
 import software.amazon.smithy.rust.codegen.core.smithy.customize.OperationSection
 import software.amazon.smithy.rust.codegen.core.smithy.customize.writeCustomizations
@@ -61,6 +62,7 @@ open class HttpBoundProtocolTraitImplGenerator(
     private val parserGenerator = ProtocolParserGenerator(codegenContext, protocol)
 
     private val codegenScope = arrayOf(
+        *preludeScope,
         "ParseStrict" to RuntimeType.parseStrictResponse(runtimeConfig),
         "ParseResponse" to RuntimeType.parseHttpResponse(runtimeConfig),
         "http" to RuntimeType.Http,
@@ -114,7 +116,7 @@ open class HttpBoundProtocolTraitImplGenerator(
         rustTemplate(
             """
             impl #{ParseStrict} for $operationName {
-                type Output = std::result::Result<#{O}, #{E}>;
+                type Output = #{Result}<#{O}, #{E}>;
                 fn parse(&self, response: &#{http}::Response<#{Bytes}>) -> Self::Output {
                      let (success, status) = (response.status().is_success(), response.status().as_u16());
                      let headers = response.headers();
@@ -144,14 +146,14 @@ open class HttpBoundProtocolTraitImplGenerator(
         rustTemplate(
             """
             impl #{ParseResponse} for $operationName {
-                type Output = std::result::Result<#{O}, #{E}>;
-                fn parse_unloaded(&self, response: &mut #{operation}::Response) -> Option<Self::Output> {
+                type Output = #{Result}<#{O}, #{E}>;
+                fn parse_unloaded(&self, response: &mut #{operation}::Response) -> #{Option}<Self::Output> {
                      #{BeforeParseResponse}
                     // This is an error, defer to the non-streaming parser
                     if !response.http().status().is_success() && response.http().status().as_u16() != $successCode {
-                        return None;
+                        return #{None};
                     }
-                    Some(#{parse_streaming_response}(response))
+                    #{Some}(#{parse_streaming_response}(response))
                 }
                 fn parse_loaded(&self, response: &#{http}::Response<#{Bytes}>) -> Self::Output {
                     // if streaming, we only hit this case if its an error
@@ -180,7 +182,7 @@ open class HttpBoundProtocolTraitImplGenerator(
         return protocolFunctions.deserializeFn(operationShape, fnNameSuffix = "op_response") { fnName ->
             Attribute.AllowClippyUnnecessaryWraps.render(this)
             rustBlockTemplate(
-                "pub fn $fnName(op_response: &mut #{operation}::Response) -> std::result::Result<#{O}, #{E}>",
+                "pub fn $fnName(op_response: &mut #{operation}::Response) -> #{Result}<#{O}, #{E}>",
                 *codegenScope,
                 "O" to outputSymbol,
                 "E" to errorSymbol,
diff --git a/codegen-client/src/test/kotlin/software/amazon/smithy/rust/codegen/client/smithy/NamingObstacleCourseTest.kt b/codegen-client/src/test/kotlin/software/amazon/smithy/rust/codegen/client/smithy/NamingObstacleCourseTest.kt
new file mode 100644
index 0000000000..aba0edc1a5
--- /dev/null
+++ b/codegen-client/src/test/kotlin/software/amazon/smithy/rust/codegen/client/smithy/NamingObstacleCourseTest.kt
@@ -0,0 +1,35 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package software.amazon.smithy.rust.codegen.client.smithy
+
+import org.junit.jupiter.api.Test
+import software.amazon.smithy.rust.codegen.client.testutil.clientIntegrationTest
+import software.amazon.smithy.rust.codegen.core.testutil.NamingObstacleCourseTestModels.rustPreludeEnumVariantsModel
+import software.amazon.smithy.rust.codegen.core.testutil.NamingObstacleCourseTestModels.rustPreludeEnumsModel
+import software.amazon.smithy.rust.codegen.core.testutil.NamingObstacleCourseTestModels.rustPreludeOperationsModel
+import software.amazon.smithy.rust.codegen.core.testutil.NamingObstacleCourseTestModels.rustPreludeStructsModel
+
+class NamingObstacleCourseTest {
+    @Test
+    fun `test Rust prelude operation names compile`() {
+        clientIntegrationTest(rustPreludeOperationsModel()) { _, _ -> }
+    }
+
+    @Test
+    fun `test Rust prelude structure names compile`() {
+        clientIntegrationTest(rustPreludeStructsModel()) { _, _ -> }
+    }
+
+    @Test
+    fun `test Rust prelude enum names compile`() {
+        clientIntegrationTest(rustPreludeEnumsModel()) { _, _ -> }
+    }
+
+    @Test
+    fun `test Rust prelude enum variant names compile`() {
+        clientIntegrationTest(rustPreludeEnumVariantsModel()) { _, _ -> }
+    }
+}
diff --git a/codegen-client/src/test/kotlin/software/amazon/smithy/rust/codegen/client/smithy/StreamingShapeSymbolProviderTest.kt b/codegen-client/src/test/kotlin/software/amazon/smithy/rust/codegen/client/smithy/StreamingShapeSymbolProviderTest.kt
index a2e233c719..61d97317f2 100644
--- a/codegen-client/src/test/kotlin/software/amazon/smithy/rust/codegen/client/smithy/StreamingShapeSymbolProviderTest.kt
+++ b/codegen-client/src/test/kotlin/software/amazon/smithy/rust/codegen/client/smithy/StreamingShapeSymbolProviderTest.kt
@@ -43,13 +43,13 @@ internal class StreamingShapeSymbolProviderTest {
         modelWithOperationTraits.lookup<MemberShape>("test.synthetic#GenerateSpeechOutput\$data").also { shape ->
             symbolProvider.toSymbol(shape).also { symbol ->
                 symbol.name shouldBe "data"
-                symbol.rustType() shouldBe RustType.Opaque("ByteStream", "aws_smithy_http::byte_stream")
+                symbol.rustType() shouldBe RustType.Opaque("ByteStream", "::aws_smithy_http::byte_stream")
             }
         }
         modelWithOperationTraits.lookup<MemberShape>("test.synthetic#GenerateSpeechInput\$data").also { shape ->
             symbolProvider.toSymbol(shape).also { symbol ->
                 symbol.name shouldBe "data"
-                symbol.rustType() shouldBe RustType.Opaque("ByteStream", "aws_smithy_http::byte_stream")
+                symbol.rustType() shouldBe RustType.Opaque("ByteStream", "::aws_smithy_http::byte_stream")
             }
         }
     }
diff --git a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/CargoDependency.kt b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/CargoDependency.kt
index 2e372b4989..6976236d85 100644
--- a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/CargoDependency.kt
+++ b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/CargoDependency.kt
@@ -197,7 +197,7 @@ data class CargoDependency(
     }
 
     fun toType(): RuntimeType {
-        return RuntimeType(rustName, this)
+        return RuntimeType("::$rustName", this)
     }
 
     companion object {
diff --git a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustModule.kt b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustModule.kt
index b8c3237e41..78dee92dae 100644
--- a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustModule.kt
+++ b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustModule.kt
@@ -79,14 +79,19 @@ sealed class RustModule {
         }
 
         /** Creates a new public module */
-        fun public(name: String, parent: RustModule = LibRs, documentationOverride: String? = null): LeafModule =
-            new(
-                name,
-                visibility = Visibility.PUBLIC,
-                inline = false,
-                parent = parent,
-                documentationOverride = documentationOverride,
-            )
+        fun public(
+            name: String,
+            parent: RustModule = LibRs,
+            documentationOverride: String? = null,
+            additionalAttributes: List<Attribute> = emptyList(),
+        ): LeafModule = new(
+            name,
+            visibility = Visibility.PUBLIC,
+            inline = false,
+            parent = parent,
+            documentationOverride = documentationOverride,
+            additionalAttributes = additionalAttributes,
+        )
 
         /** Creates a new private module */
         fun private(name: String, parent: RustModule = LibRs): LeafModule =
diff --git a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustType.kt b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustType.kt
index 79dde7de12..6d010089d2 100644
--- a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustType.kt
+++ b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustType.kt
@@ -199,7 +199,7 @@ fun RustType.qualifiedName(): String {
 
 /** Format this Rust type as an `impl Into<T>` */
 fun RustType.implInto(fullyQualified: Boolean = true): String {
-    return "impl Into<${this.render(fullyQualified)}>"
+    return "impl ${RuntimeType.Into.fullyQualifiedName()}<${this.render(fullyQualified)}>"
 }
 
 /** Format this Rust type so that it may be used as an argument type in a function definition */
@@ -498,6 +498,7 @@ class Attribute(val inner: Writable, val isDeriveHelper: Boolean = false) {
         val DenyMissingDocs = Attribute(deny("missing_docs"))
         val DocHidden = Attribute(doc("hidden"))
         val DocInline = Attribute(doc("inline"))
+        val NoImplicitPrelude = Attribute("no_implicit_prelude")
         fun shouldPanic(expectedMessage: String) =
             Attribute(macroWithArgs("should_panic", "expected = ${expectedMessage.dq()}"))
 
diff --git a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustWriter.kt b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustWriter.kt
index 61f219488a..007f5e24d3 100644
--- a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustWriter.kt
+++ b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustWriter.kt
@@ -26,6 +26,7 @@ import software.amazon.smithy.model.traits.DocumentationTrait
 import software.amazon.smithy.rust.codegen.core.rustlang.Attribute.Companion.deprecated
 import software.amazon.smithy.rust.codegen.core.smithy.ModuleDocProvider
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.preludeScope
 import software.amazon.smithy.rust.codegen.core.smithy.isOptional
 import software.amazon.smithy.rust.codegen.core.smithy.protocols.serialize.ValueExpression
 import software.amazon.smithy.rust.codegen.core.smithy.rustType
@@ -142,6 +143,21 @@ fun <T : AbstractCodeWriter<T>> T.conditionalBlock(
     return this
 }
 
+fun RustWriter.conditionalBlockTemplate(
+    textBeforeNewLine: String,
+    textAfterNewLine: String,
+    conditional: Boolean = true,
+    vararg args: Pair<String, Any>,
+    block: RustWriter.() -> Unit,
+): RustWriter {
+    withTemplate(textBeforeNewLine.trim(), args) { beforeNewLine ->
+        withTemplate(textAfterNewLine.trim(), args) { afterNewLine ->
+            conditionalBlock(beforeNewLine, afterNewLine, conditional = conditional, block = block)
+        }
+    }
+    return this
+}
+
 /**
  * Convenience wrapper that tells Intellij that the contents of this block are Rust
  */
@@ -608,7 +624,7 @@ class RustWriter private constructor(
         when {
             member.isOptional() -> {
                 val innerValue = ValueExpression.Reference(safeName("inner"))
-                rustBlock("if let Some(${innerValue.name}) = ${value.asRef()}") {
+                rustBlockTemplate("if let #{Some}(${innerValue.name}) = ${value.asRef()}", *preludeScope) {
                     block(innerValue)
                 }
             }
diff --git a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/RuntimeType.kt b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/RuntimeType.kt
index f8c656c08e..6e5b5ee8ff 100644
--- a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/RuntimeType.kt
+++ b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/RuntimeType.kt
@@ -193,14 +193,67 @@ data class RuntimeType(val path: String, val dependency: RustDependency? = null)
      * The companion object contains commonly used RuntimeTypes
      */
     companion object {
+        /**
+         * Scope that contains all Rust prelude types, but not macros or functions.
+         *
+         * Prelude docs: https://doc.rust-lang.org/std/prelude/index.html#prelude-contents
+         */
+        val preludeScope by lazy {
+            arrayOf(
+                // Rust 1.0
+                "Copy" to std.resolve("marker::Copy"),
+                "Send" to Send,
+                "Sized" to std.resolve("marker::Sized"),
+                "Sync" to Sync,
+                "Unpin" to std.resolve("marker::Unpin"),
+                "Drop" to std.resolve("ops::Drop"),
+                "Fn" to std.resolve("ops::Fn"),
+                "FnMut" to std.resolve("ops::FnMut"),
+                "FnOnce" to std.resolve("ops::FnOnce"),
+                "Box" to Box,
+                "ToOwned" to std.resolve("borrow::ToOwned"),
+                "Clone" to Clone,
+                "PartialEq" to std.resolve("cmp::PartialEq"),
+                "PartialOrd" to std.resolve("cmp::PartialOrd"),
+                "Eq" to Eq,
+                "Ord" to Ord,
+                "AsRef" to AsRef,
+                "AsMut" to std.resolve("convert::AsMut"),
+                "Into" to Into,
+                "From" to From,
+                "Default" to Default,
+                "Iterator" to std.resolve("iter::Iterator"),
+                "Extend" to std.resolve("iter::Extend"),
+                "IntoIterator" to std.resolve("iter::IntoIterator"),
+                "DoubleEndedIterator" to std.resolve("iter::DoubleEndedIterator"),
+                "ExactSizeIterator" to std.resolve("iter::ExactSizeIterator"),
+                "Option" to Option,
+                "Some" to Option.resolve("Some"),
+                "None" to Option.resolve("None"),
+                "Result" to std.resolve("result::Result"),
+                "Ok" to std.resolve("result::Result::Ok"),
+                "Err" to std.resolve("result::Result::Err"),
+                "String" to String,
+                "ToString" to std.resolve("string::ToString"),
+                "Vec" to Vec,
+
+                // 2021 Edition
+                "TryFrom" to std.resolve("convert::TryFrom"),
+                "TryInto" to std.resolve("convert::TryInto"),
+                "FromIterator" to std.resolve("iter::FromIterator"),
+            )
+        }
+
         // stdlib types
-        val std = RuntimeType("std")
+        val std = RuntimeType("::std")
         val stdCmp = std.resolve("cmp")
         val stdFmt = std.resolve("fmt")
         val stdConvert = std.resolve("convert")
+        val Arc = std.resolve("sync::Arc")
         val AsRef = stdConvert.resolve("AsRef")
-        val ByteSlab = std.resolve("vec::Vec<u8>")
+        val Bool = std.resolve("primitive::bool")
         val Box = std.resolve("boxed::Box")
+        val ByteSlab = std.resolve("vec::Vec<u8>")
         val Clone = std.resolve("clone::Clone")
         val Cow = std.resolve("borrow::Cow")
         val Debug = stdFmt.resolve("Debug")
@@ -210,19 +263,18 @@ data class RuntimeType(val path: String, val dependency: RustDependency? = null)
         val From = stdConvert.resolve("From")
         val Hash = std.resolve("hash::Hash")
         val HashMap = std.resolve("collections::HashMap")
-        val Ord = stdCmp.resolve("Ord")
+        val Into = stdConvert.resolve("Into")
         val Option = std.resolve("option::Option")
+        val Ord = stdCmp.resolve("Ord")
         val PartialEq = stdCmp.resolve("PartialEq")
         val PartialOrd = stdCmp.resolve("PartialOrd")
         val Phantom = std.resolve("marker::PhantomData")
+        val Send = std.resolve("marker::Send")
         val StdError = std.resolve("error::Error")
         val String = std.resolve("string::String")
-        val Bool = std.resolve("primitive::bool")
+        val Sync = std.resolve("marker::Sync")
         val TryFrom = stdConvert.resolve("TryFrom")
         val Vec = std.resolve("vec::Vec")
-        val Arc = std.resolve("sync::Arc")
-        val Send = std.resolve("marker::Send")
-        val Sync = std.resolve("marker::Sync")
 
         // external cargo dependency types
         val Bytes = CargoDependency.Bytes.toType().resolve("Bytes")
diff --git a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/BuilderGenerator.kt b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/BuilderGenerator.kt
index 16cb28b803..da008a6bee 100644
--- a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/BuilderGenerator.kt
+++ b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/BuilderGenerator.kt
@@ -17,13 +17,14 @@ import software.amazon.smithy.rust.codegen.core.rustlang.RustWriter
 import software.amazon.smithy.rust.codegen.core.rustlang.Writable
 import software.amazon.smithy.rust.codegen.core.rustlang.asArgument
 import software.amazon.smithy.rust.codegen.core.rustlang.asOptional
-import software.amazon.smithy.rust.codegen.core.rustlang.conditionalBlock
+import software.amazon.smithy.rust.codegen.core.rustlang.conditionalBlockTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.deprecatedShape
 import software.amazon.smithy.rust.codegen.core.rustlang.docs
 import software.amazon.smithy.rust.codegen.core.rustlang.documentShape
 import software.amazon.smithy.rust.codegen.core.rustlang.render
 import software.amazon.smithy.rust.codegen.core.rustlang.rust
 import software.amazon.smithy.rust.codegen.core.rustlang.rustBlock
+import software.amazon.smithy.rust.codegen.core.rustlang.rustBlockTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.rustTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.stripOuter
 import software.amazon.smithy.rust.codegen.core.rustlang.withBlock
@@ -31,6 +32,7 @@ import software.amazon.smithy.rust.codegen.core.rustlang.writable
 import software.amazon.smithy.rust.codegen.core.smithy.Default
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeConfig
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.preludeScope
 import software.amazon.smithy.rust.codegen.core.smithy.RustSymbolProvider
 import software.amazon.smithy.rust.codegen.core.smithy.canUseDefault
 import software.amazon.smithy.rust.codegen.core.smithy.customize.NamedCustomization
@@ -126,7 +128,6 @@ class BuilderGenerator(
     private val runtimeConfig = symbolProvider.config.runtimeConfig
     private val members: List<MemberShape> = shape.allMembers.values.toList()
     private val structureSymbol = symbolProvider.toSymbol(shape)
-    private val builderSymbol = symbolProvider.symbolForBuilder(shape)
     private val metadata = structureSymbol.expectRustMetadata()
 
     // Filter out any derive that isn't Debug, PartialEq, or Clone. Then add a Default derive
@@ -147,12 +148,12 @@ class BuilderGenerator(
         val fallibleBuilder = hasFallibleBuilder(shape, symbolProvider)
         val outputSymbol = symbolProvider.toSymbol(shape)
         val returnType = when (fallibleBuilder) {
-            true -> "Result<${implBlockWriter.format(outputSymbol)}, ${implBlockWriter.format(runtimeConfig.operationBuildError())}>"
+            true -> "#{Result}<${implBlockWriter.format(outputSymbol)}, ${implBlockWriter.format(runtimeConfig.operationBuildError())}>"
             false -> implBlockWriter.format(outputSymbol)
         }
         implBlockWriter.docs("Consumes the builder and constructs a #D.", outputSymbol)
-        implBlockWriter.rustBlock("pub fn build(self) -> $returnType") {
-            conditionalBlock("Ok(", ")", conditional = fallibleBuilder) {
+        implBlockWriter.rustBlockTemplate("pub fn build(self) -> $returnType", *preludeScope) {
+            conditionalBlockTemplate("#{Ok}(", ")", conditional = fallibleBuilder, *preludeScope) {
                 // If a wrapper is specified, use the `::new` associated function to construct the wrapper
                 coreBuilder(this)
             }
@@ -182,7 +183,7 @@ class BuilderGenerator(
         writer.documentShape(member, model)
         writer.deprecatedShape(member)
         writer.rustBlock("pub fn $memberName(mut self, ${input.argument}) -> Self") {
-            write("self.$memberName = Some(${input.value});")
+            rustTemplate("self.$memberName = #{Some}(${input.value});", *preludeScope)
             write("self")
         }
     }
@@ -273,13 +274,14 @@ class BuilderGenerator(
         val input = coreType.member.asArgument("input")
 
         rustBlock("pub fn $memberName(mut self, ${input.argument}) -> Self") {
-            rust(
+            rustTemplate(
                 """
                 let mut v = self.$memberName.unwrap_or_default();
                 v.push(${input.value});
-                self.$memberName = Some(v);
+                self.$memberName = #{Some}(v);
                 self
                 """,
+                *preludeScope,
             )
         }
     }
@@ -297,13 +299,14 @@ class BuilderGenerator(
         rustBlock(
             "pub fn $memberName(mut self, ${k.argument}, ${v.argument}) -> Self",
         ) {
-            rust(
+            rustTemplate(
                 """
                 let mut hash_map = self.$memberName.unwrap_or_default();
                 hash_map.insert(${k.value}, ${v.value});
-                self.$memberName = Some(hash_map);
+                self.$memberName = #{Some}(hash_map);
                 self
                 """,
+                *preludeScope,
             )
         }
     }
diff --git a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/EnumGenerator.kt b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/EnumGenerator.kt
index 379a6982da..a84820ad26 100644
--- a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/EnumGenerator.kt
+++ b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/EnumGenerator.kt
@@ -27,6 +27,7 @@ import software.amazon.smithy.rust.codegen.core.rustlang.rustTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.writable
 import software.amazon.smithy.rust.codegen.core.smithy.MaybeRenamed
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.preludeScope
 import software.amazon.smithy.rust.codegen.core.smithy.RustSymbolProvider
 import software.amazon.smithy.rust.codegen.core.smithy.expectRustMetadata
 import software.amazon.smithy.rust.codegen.core.smithy.renamedFrom
@@ -208,14 +209,15 @@ open class EnumGenerator(
                 }
             },
         )
-        rust(
+        rustTemplate(
             """
-            impl AsRef<str> for ${context.enumName} {
+            impl #{AsRef}<str> for ${context.enumName} {
                 fn as_ref(&self) -> &str {
                     self.as_str()
                 }
             }
             """,
+            *preludeScope,
         )
     }
 
@@ -238,8 +240,7 @@ open class EnumGenerator(
                 }
             }
             """,
-            "From" to RuntimeType.From,
-            "AsRef" to RuntimeType.AsRef,
+            *preludeScope,
         )
     }
 
@@ -295,7 +296,7 @@ open class EnumGenerator(
             """
             impl #{Debug} for ${context.enumName} {
                 fn fmt(&self, f: &mut #{StdFmt}::Formatter<'_>) -> #{StdFmt}::Result {
-                    write!(f, $REDACTION)
+                    ::std::write!(f, $REDACTION)
                 }
             }
             """,
diff --git a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/Instantiator.kt b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/Instantiator.kt
index e77f942a29..3a59bc1bcd 100644
--- a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/Instantiator.kt
+++ b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/Instantiator.kt
@@ -37,7 +37,7 @@ import software.amazon.smithy.rust.codegen.core.rustlang.CargoDependency
 import software.amazon.smithy.rust.codegen.core.rustlang.RustType
 import software.amazon.smithy.rust.codegen.core.rustlang.RustWriter
 import software.amazon.smithy.rust.codegen.core.rustlang.Writable
-import software.amazon.smithy.rust.codegen.core.rustlang.conditionalBlock
+import software.amazon.smithy.rust.codegen.core.rustlang.conditionalBlockTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.escape
 import software.amazon.smithy.rust.codegen.core.rustlang.rust
 import software.amazon.smithy.rust.codegen.core.rustlang.rustBlock
@@ -47,6 +47,7 @@ import software.amazon.smithy.rust.codegen.core.rustlang.withBlock
 import software.amazon.smithy.rust.codegen.core.rustlang.writable
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeConfig
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.preludeScope
 import software.amazon.smithy.rust.codegen.core.smithy.RustSymbolProvider
 import software.amazon.smithy.rust.codegen.core.smithy.customize.NamedCustomization
 import software.amazon.smithy.rust.codegen.core.smithy.customize.Section
@@ -204,21 +205,23 @@ open class Instantiator(
             check(symbol.isOptional()) {
                 "A null node was provided for $memberShape but the symbol was not optional. This is invalid input data."
             }
-            writer.rust("None")
+            writer.rustTemplate("#{None}", *preludeScope)
         } else {
             // Structure builder setters for structure shape members _always_ take in `Option<T>`.
             // Other aggregate shapes' members are optional only when their symbol is.
-            writer.conditionalBlock(
-                "Some(",
+            writer.conditionalBlockTemplate(
+                "#{Some}(",
                 ")",
                 // The conditions are not commutative: note client builders always take in `Option<T>`.
                 conditional = symbol.isOptional() ||
                     (model.expectShape(memberShape.container) is StructureShape && builderKindBehavior.doesSetterTakeInOption(memberShape)),
+                *preludeScope,
             ) {
-                writer.conditionalBlock(
-                    "Box::new(",
+                writer.conditionalBlockTemplate(
+                    "#{Box}::new(",
                     ")",
                     conditional = symbol.rustType().stripOuter<RustType.Option>() is RustType.Box,
+                    *preludeScope,
                 ) {
                     render(
                         this,
diff --git a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/UnionGenerator.kt b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/UnionGenerator.kt
index 39b191ba96..3f7927d728 100644
--- a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/UnionGenerator.kt
+++ b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/UnionGenerator.kt
@@ -19,9 +19,11 @@ import software.amazon.smithy.rust.codegen.core.rustlang.documentShape
 import software.amazon.smithy.rust.codegen.core.rustlang.render
 import software.amazon.smithy.rust.codegen.core.rustlang.rust
 import software.amazon.smithy.rust.codegen.core.rustlang.rustBlock
+import software.amazon.smithy.rust.codegen.core.rustlang.rustBlockTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.rustTemplate
 import software.amazon.smithy.rust.codegen.core.smithy.CodegenTarget
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.preludeScope
 import software.amazon.smithy.rust.codegen.core.smithy.expectRustMetadata
 import software.amazon.smithy.rust.codegen.core.smithy.renamedFrom
 import software.amazon.smithy.rust.codegen.core.smithy.rustType
@@ -134,7 +136,7 @@ open class UnionGenerator(
             """
             impl #{Debug} for ${unionSymbol.name} {
                 fn fmt(&self, f: &mut #{StdFmt}::Formatter<'_>) -> #{StdFmt}::Result {
-                    write!(f, $REDACTION)
+                    ::std::write!(f, $REDACTION)
                 }
             }
             """,
@@ -197,8 +199,11 @@ private fun RustWriter.renderAsVariant(
             "/// Tries to convert the enum instance into [`$variantName`], extracting the inner `()`.",
         )
         rust("/// Returns `Err(&Self)` if it can't be converted.")
-        rustBlock("pub fn as_$funcNamePart(&self) -> std::result::Result<(), &Self>") {
-            rust("if let ${unionSymbol.name}::$variantName = &self { Ok(()) } else { Err(self) }")
+        rustBlockTemplate("pub fn as_$funcNamePart(&self) -> #{Result}<(), &Self>", *preludeScope) {
+            rustTemplate(
+                "if let ${unionSymbol.name}::$variantName = &self { #{Ok}(()) } else { #{Err}(self) }",
+                *preludeScope,
+            )
         }
     } else {
         val memberSymbol = symbolProvider.toSymbol(member)
@@ -209,8 +214,11 @@ private fun RustWriter.renderAsVariant(
             targetSymbol,
         )
         rust("/// Returns `Err(&Self)` if it can't be converted.")
-        rustBlock("pub fn as_$funcNamePart(&self) -> std::result::Result<&${memberSymbol.rustType().render()}, &Self>") {
-            rust("if let ${unionSymbol.name}::$variantName(val) = &self { Ok(val) } else { Err(self) }")
+        rustBlockTemplate("pub fn as_$funcNamePart(&self) -> #{Result}<&${memberSymbol.rustType().render()}, &Self>", *preludeScope) {
+            rustTemplate(
+                "if let ${unionSymbol.name}::$variantName(val) = &self { #{Ok}(val) } else { #{Err}(self) }",
+                *preludeScope,
+            )
         }
     }
 }
diff --git a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/error/ErrorImplGenerator.kt b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/error/ErrorImplGenerator.kt
index 692bf32aab..049933bc45 100644
--- a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/error/ErrorImplGenerator.kt
+++ b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/error/ErrorImplGenerator.kt
@@ -156,13 +156,13 @@ class ErrorImplGenerator(
                 val errorDesc = symbol.name.letIf(symbol.name != shape.id.name) { symbolName ->
                     "$symbolName [${shape.id.name}]"
                 }
-                write("write!(f, ${errorDesc.dq()})?;")
+                write("::std::write!(f, ${errorDesc.dq()})?;")
                 messageShape?.let {
                     if (it.shouldRedact(model)) {
-                        write("""write!(f, ": {}", $REDACTION)?;""")
+                        write("""::std::write!(f, ": {}", $REDACTION)?;""")
                     } else {
                         ifSet(it, symbolProvider.toSymbol(it), ValueExpression.Reference("&self.message")) { field ->
-                            write("""write!(f, ": {}", ${field.asRef()})?;""")
+                            write("""::std::write!(f, ": {}", ${field.asRef()})?;""")
                         }
                     }
                 }
diff --git a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/protocols/parse/EventStreamUnmarshallerGenerator.kt b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/protocols/parse/EventStreamUnmarshallerGenerator.kt
index 6e9826f054..6b706a1e09 100644
--- a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/protocols/parse/EventStreamUnmarshallerGenerator.kt
+++ b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/protocols/parse/EventStreamUnmarshallerGenerator.kt
@@ -276,7 +276,7 @@ class EventStreamUnmarshallerGenerator(
                     is StringShape -> {
                         rustTemplate(
                             """
-                            std::str::from_utf8(message.payload())
+                            ::std::str::from_utf8(message.payload())
                                 .map_err(|_| #{Error}::unmarshalling("message payload is not valid UTF-8"))?
                                 .to_owned()
                             """,
diff --git a/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/testutil/NamingObstacleCourseTestModels.kt b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/testutil/NamingObstacleCourseTestModels.kt
new file mode 100644
index 0000000000..c45a7d0992
--- /dev/null
+++ b/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/testutil/NamingObstacleCourseTestModels.kt
@@ -0,0 +1,172 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package software.amazon.smithy.rust.codegen.core.testutil
+
+import software.amazon.smithy.model.Model
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.preludeScope
+
+object NamingObstacleCourseTestModels {
+    private val rustPrelude = preludeScope.map { pair -> pair.first }
+
+    /**
+     * Test model that confounds the generation machinery by using operations named after every item
+     * in the Rust prelude.
+     */
+    fun rustPreludeOperationsModel(): Model = StringBuilder().apply {
+        append(
+            """
+            ${"$"}version: "2.0"
+            namespace crate
+
+            use smithy.test#httpRequestTests
+            use smithy.test#httpResponseTests
+            use aws.protocols#awsJson1_1
+            use aws.api#service
+            use smithy.framework#ValidationException
+
+            structure InputAndOutput {}
+
+            @awsJson1_1
+            @service(sdkId: "Config")
+            service Config {
+                version: "2006-03-01",
+                rename: { "smithy.api#String": "PreludeString" },
+                operations: [
+            """,
+        )
+        for (item in rustPrelude) {
+            append("$item,\n")
+        }
+        append(
+            """
+            ]
+            }
+            """,
+        )
+        for (item in rustPrelude) {
+            append("operation $item { input: InputAndOutput, output: InputAndOutput, errors: [ValidationException] }\n")
+        }
+    }.toString().asSmithyModel()
+
+    fun rustPreludeStructsModel(): Model = StringBuilder().apply {
+        append(
+            """
+            ${"$"}version: "2.0"
+            namespace crate
+
+            use smithy.test#httpRequestTests
+            use smithy.test#httpResponseTests
+            use aws.protocols#awsJson1_1
+            use aws.api#service
+            use smithy.framework#ValidationException
+
+            structure InputAndOutput {}
+
+            @awsJson1_1
+            @service(sdkId: "Config")
+            service Config {
+                version: "2006-03-01",
+                rename: { "smithy.api#String": "PreludeString" },
+                operations: [
+            """,
+        )
+        for (item in rustPrelude) {
+            append("Use$item,\n")
+        }
+        append(
+            """
+            ]
+            }
+            """,
+        )
+        for (item in rustPrelude) {
+            append("structure $item { $item: smithy.api#String }\n")
+            append("operation Use$item { input: $item, output: $item, errors: [ValidationException] }\n")
+        }
+        println(toString())
+    }.toString().asSmithyModel()
+
+    fun rustPreludeEnumsModel(): Model = StringBuilder().apply {
+        append(
+            """
+            ${"$"}version: "2.0"
+            namespace crate
+
+            use smithy.test#httpRequestTests
+            use smithy.test#httpResponseTests
+            use aws.protocols#awsJson1_1
+            use aws.api#service
+            use smithy.framework#ValidationException
+
+            structure InputAndOutput {}
+
+            @awsJson1_1
+            @service(sdkId: "Config")
+            service Config {
+                version: "2006-03-01",
+                rename: { "smithy.api#String": "PreludeString" },
+                operations: [
+            """,
+        )
+        for (item in rustPrelude) {
+            append("Use$item,\n")
+        }
+        append(
+            """
+            ]
+            }
+            """,
+        )
+        for (item in rustPrelude) {
+            append("enum $item { $item }\n")
+            append("structure Struct$item { $item: $item }\n")
+            append("operation Use$item { input: Struct$item, output: Struct$item, errors: [ValidationException] }\n")
+        }
+    }.toString().asSmithyModel()
+
+    fun rustPreludeEnumVariantsModel(): Model = StringBuilder().apply {
+        append(
+            """
+            ${"$"}version: "2.0"
+            namespace crate
+
+            use smithy.test#httpRequestTests
+            use smithy.test#httpResponseTests
+            use aws.protocols#awsJson1_1
+            use aws.api#service
+            use smithy.framework#ValidationException
+
+            @awsJson1_1
+            @service(sdkId: "Config")
+            service Config {
+                version: "2006-03-01",
+                rename: { "smithy.api#String": "PreludeString" },
+                operations: [EnumOp]
+            }
+
+            operation EnumOp {
+                input: InputAndOutput,
+                output: InputAndOutput,
+                errors: [ValidationException],
+            }
+
+            structure InputAndOutput {
+                the_enum: TheEnum,
+            }
+
+            enum TheEnum {
+            """,
+        )
+        for (item in rustPrelude) {
+            append("$item,\n")
+        }
+        append(
+            """
+            }
+            """,
+        )
+    }.toString().asSmithyModel()
+}
diff --git a/codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustTypeTest.kt b/codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustTypeTest.kt
index 7fa364dfaf..1c89f39058 100644
--- a/codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustTypeTest.kt
+++ b/codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustTypeTest.kt
@@ -54,14 +54,14 @@ internal class RustTypesTest {
 
     @Test
     fun `RustType_String_writable produces a template-compatible RuntimeType`() {
-        forInputExpectOutput(RustType.String.writable, "'std::string::String'")
+        forInputExpectOutput(RustType.String.writable, "'::std::string::String'")
     }
 
     @Test
     fun `RustType_Vec_writable produces a template-compatible RuntimeType`() {
         forInputExpectOutput(
             RustType.Vec(RustType.String).writable,
-            "'std::vec::Vec<std::string::String>'",
+            "'::std::vec::Vec<::std::string::String>'",
         )
     }
 
@@ -69,7 +69,7 @@ internal class RustTypesTest {
     fun `RustType_Slice_writable produces a template-compatible RuntimeType`() {
         forInputExpectOutput(
             RustType.Slice(RustType.String).writable,
-            "'[std::string::String]'",
+            "'[::std::string::String]'",
         )
     }
 
@@ -77,7 +77,7 @@ internal class RustTypesTest {
     fun `RustType_HashMap_writable produces a template-compatible RuntimeType`() {
         forInputExpectOutput(
             RustType.HashMap(RustType.String, RustType.String).writable,
-            "'std::collections::HashMap<std::string::String, std::string::String>'",
+            "'::std::collections::HashMap<::std::string::String, ::std::string::String>'",
         )
     }
 
@@ -87,7 +87,7 @@ internal class RustTypesTest {
             RustType.HashSet(RustType.String).writable,
             // Rust doesn't guarantee that `HashSet`s are insertion ordered, so we use a `Vec` instead.
             // This is called out in a comment in the RustType.HashSet declaration
-            "'std::vec::Vec<std::string::String>'",
+            "'::std::vec::Vec<::std::string::String>'",
         )
     }
 
@@ -95,15 +95,15 @@ internal class RustTypesTest {
     fun `RustType_Reference_writable produces a template-compatible RuntimeType`() {
         forInputExpectOutput(
             RustType.Reference("&", RustType.String).writable,
-            "'&std::string::String'",
+            "'&::std::string::String'",
         )
         forInputExpectOutput(
             RustType.Reference("&mut", RustType.String).writable,
-            "'&mut std::string::String'",
+            "'&mut ::std::string::String'",
         )
         forInputExpectOutput(
             RustType.Reference("&'static", RustType.String).writable,
-            "&'static std::string::String'",
+            "&'static ::std::string::String'",
         )
     }
 
@@ -111,7 +111,7 @@ internal class RustTypesTest {
     fun `RustType_Option_writable produces a template-compatible RuntimeType`() {
         forInputExpectOutput(
             RustType.Option(RustType.String).writable,
-            "'std::option::Option<std::string::String>'",
+            "'::std::option::Option<::std::string::String>'",
         )
     }
 
@@ -119,7 +119,7 @@ internal class RustTypesTest {
     fun `RustType_Box_writable produces a template-compatible RuntimeType`() {
         forInputExpectOutput(
             RustType.Box(RustType.String).writable,
-            "'std::boxed::Box<std::string::String>'",
+            "'::std::boxed::Box<::std::string::String>'",
         )
     }
 
@@ -147,7 +147,7 @@ internal class RustTypesTest {
     fun `types render properly`() {
         val type = RustType.Box(RustType.Option(RustType.Reference("a", RustType.Vec(RustType.String))))
         type.render(false) shouldBe "Box<Option<&'a Vec<String>>>"
-        type.render(true) shouldBe "std::boxed::Box<std::option::Option<&'a std::vec::Vec<std::string::String>>>"
+        type.render(true) shouldBe "::std::boxed::Box<::std::option::Option<&'a ::std::vec::Vec<::std::string::String>>>"
     }
 
     @Test
@@ -211,7 +211,7 @@ internal class RustTypesTest {
             writable {
                 attributeMacro.render(this)
             },
-            "#[derive(std::clone::Clone, std::error::Error, std::fmt::Debug)]\n",
+            "#[derive(::std::clone::Clone, ::std::error::Error, ::std::fmt::Debug)]\n",
         )
     }
 
diff --git a/codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustWriterTest.kt b/codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustWriterTest.kt
index ac14bcd20f..2bd5269cc2 100644
--- a/codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustWriterTest.kt
+++ b/codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustWriterTest.kt
@@ -143,7 +143,7 @@ class RustWriterTest {
         )
         val sut = RustWriter.root()
         metadata.render(sut)
-        sut.toString().shouldContain("#[allow(deprecated)]\n#[derive(std::fmt::Debug)]\n#[foo]")
+        sut.toString().shouldContain("#[allow(deprecated)]\n#[derive(::std::fmt::Debug)]\n#[foo]")
     }
 
     @Test
@@ -183,7 +183,7 @@ class RustWriterTest {
             "Inner" to inner,
             "http" to RuntimeType.Http.resolve("foo"),
         )
-        sut.toString().shouldContain("inner: hello, regular: http::foo")
+        sut.toString().shouldContain("inner: hello, regular: ::http::foo")
     }
 
     @Test
diff --git a/codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/WritableTest.kt b/codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/WritableTest.kt
index 7da0562451..04c5ff2f1a 100644
--- a/codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/WritableTest.kt
+++ b/codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/WritableTest.kt
@@ -33,7 +33,7 @@ internal class RustTypeParametersTest {
     @Test
     fun `rustTypeParameters accepts RuntimeType`() {
         val runtimeType = RuntimeType.String
-        forInputExpectOutput(runtimeType, "'<std::string::String>'")
+        forInputExpectOutput(runtimeType, "'<::std::string::String>'")
     }
 
     @Test
@@ -60,7 +60,7 @@ internal class RustTypeParametersTest {
         writer.rustInlineTemplate("#{tps:W}", "tps" to tps)
         writer.rustInlineTemplate("'")
 
-        writer.toString() shouldContain "'<crate::operation::Operation, (), std::string::String, T, A, B>'"
+        writer.toString() shouldContain "'<crate::operation::Operation, (), ::std::string::String, T, A, B>'"
     }
 
     @Test
diff --git a/codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/smithy/customizations/SmithyTypesPubUseExtraTest.kt b/codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/smithy/customizations/SmithyTypesPubUseExtraTest.kt
index 120fc5cb20..55b792218f 100644
--- a/codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/smithy/customizations/SmithyTypesPubUseExtraTest.kt
+++ b/codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/smithy/customizations/SmithyTypesPubUseExtraTest.kt
@@ -74,38 +74,38 @@ class SmithyTypesPubUseExtraTest {
 
     @Test
     fun `it re-exports Blob when a model uses blobs`() {
-        assertDoesntHaveType(typesWithEmptyModel(), "aws_smithy_types::Blob")
-        assertHasType(typesWithMember(inputMember = "foo: Blob"), "aws_smithy_types::Blob")
-        assertHasType(typesWithMember(outputMember = "foo: Blob"), "aws_smithy_types::Blob")
+        assertDoesntHaveType(typesWithEmptyModel(), "::aws_smithy_types::Blob")
+        assertHasType(typesWithMember(inputMember = "foo: Blob"), "::aws_smithy_types::Blob")
+        assertHasType(typesWithMember(outputMember = "foo: Blob"), "::aws_smithy_types::Blob")
         assertHasType(
             typesWithMember(inputMember = "foo: SomeUnion", unionMember = "foo: Blob"),
-            "aws_smithy_types::Blob",
+            "::aws_smithy_types::Blob",
         )
         assertHasType(
             typesWithMember(outputMember = "foo: SomeUnion", unionMember = "foo: Blob"),
-            "aws_smithy_types::Blob",
+            "::aws_smithy_types::Blob",
         )
     }
 
     @Test
     fun `it re-exports DateTime when a model uses timestamps`() {
         assertDoesntHaveType(typesWithEmptyModel(), "aws_smithy_types::DateTime")
-        assertHasType(typesWithMember(inputMember = "foo: Timestamp"), "aws_smithy_types::DateTime")
-        assertHasType(typesWithMember(outputMember = "foo: Timestamp"), "aws_smithy_types::DateTime")
+        assertHasType(typesWithMember(inputMember = "foo: Timestamp"), "::aws_smithy_types::DateTime")
+        assertHasType(typesWithMember(outputMember = "foo: Timestamp"), "::aws_smithy_types::DateTime")
         assertHasType(
             typesWithMember(inputMember = "foo: SomeUnion", unionMember = "foo: Timestamp"),
-            "aws_smithy_types::DateTime",
+            "::aws_smithy_types::DateTime",
         )
         assertHasType(
             typesWithMember(outputMember = "foo: SomeUnion", unionMember = "foo: Timestamp"),
-            "aws_smithy_types::DateTime",
+            "::aws_smithy_types::DateTime",
         )
     }
 
     @Test
     fun `it re-exports ByteStream and AggregatedBytes when a model has streaming`() {
         val streamingTypes =
-            listOf("aws_smithy_http::byte_stream::ByteStream", "aws_smithy_http::byte_stream::AggregatedBytes")
+            listOf("::aws_smithy_http::byte_stream::ByteStream", "::aws_smithy_http::byte_stream::AggregatedBytes")
         val streamingShape = "@streaming blob Streaming"
 
         assertDoesntHaveTypes(typesWithEmptyModel(), streamingTypes)
diff --git a/codegen-server/python/src/main/kotlin/software/amazon/smithy/rust/codegen/server/python/smithy/PythonType.kt b/codegen-server/python/src/main/kotlin/software/amazon/smithy/rust/codegen/server/python/smithy/PythonType.kt
index 42f878d6fc..8cdc481b39 100644
--- a/codegen-server/python/src/main/kotlin/software/amazon/smithy/rust/codegen/server/python/smithy/PythonType.kt
+++ b/codegen-server/python/src/main/kotlin/software/amazon/smithy/rust/codegen/server/python/smithy/PythonType.kt
@@ -111,6 +111,13 @@ sealed class PythonType {
                 else -> it
             }
         }
+            // Most opaque types have a leading `::`, so strip that for Python as needed
+            .let {
+                when (it?.startsWith(".")) {
+                    true -> it.substring(1)
+                    else -> it
+                }
+            }
     }
 }
 
diff --git a/codegen-server/python/src/test/kotlin/software/amazon/smithy/rust/codegen/server/python/smithy/generators/PythonServerSymbolProviderTest.kt b/codegen-server/python/src/test/kotlin/software/amazon/smithy/rust/codegen/server/python/smithy/generators/PythonServerSymbolProviderTest.kt
index c7467b58ed..e3ab955a9f 100644
--- a/codegen-server/python/src/test/kotlin/software/amazon/smithy/rust/codegen/server/python/smithy/generators/PythonServerSymbolProviderTest.kt
+++ b/codegen-server/python/src/test/kotlin/software/amazon/smithy/rust/codegen/server/python/smithy/generators/PythonServerSymbolProviderTest.kt
@@ -16,8 +16,8 @@ import software.amazon.smithy.rust.codegen.server.smithy.testutil.ServerTestRust
 import software.amazon.smithy.rust.codegen.server.smithy.testutil.serverTestRustSettings
 
 internal class PythonServerSymbolProviderTest {
-    private val pythonBlobType = RustType.Opaque("Blob", "aws_smithy_http_server_python::types")
-    private val pythonTimestampType = RustType.Opaque("DateTime", "aws_smithy_http_server_python::types")
+    private val pythonBlobType = RustType.Opaque("Blob", "::aws_smithy_http_server_python::types")
+    private val pythonTimestampType = RustType.Opaque("DateTime", "::aws_smithy_http_server_python::types")
 
     @Test
     fun `python symbol provider rewrites timestamp shape symbol`() {
diff --git a/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedCollectionGenerator.kt b/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedCollectionGenerator.kt
index 9b5775478e..f705e4af3a 100644
--- a/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedCollectionGenerator.kt
+++ b/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedCollectionGenerator.kt
@@ -72,7 +72,7 @@ class ConstrainedCollectionGenerator(
         }
 
         val name = constrainedShapeSymbolProvider.toSymbol(shape).name
-        val inner = "std::vec::Vec<#{ValueMemberSymbol}>"
+        val inner = "::std::vec::Vec<#{ValueMemberSymbol}>"
         val constraintViolation = constraintViolationSymbolProvider.toSymbol(shape)
         val constrainedSymbol = symbolProvider.toSymbol(shape)
 
diff --git a/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedTraitForEnumGenerator.kt b/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedTraitForEnumGenerator.kt
index 44992f4a48..8e52d0d4da 100644
--- a/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedTraitForEnumGenerator.kt
+++ b/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedTraitForEnumGenerator.kt
@@ -11,6 +11,7 @@ import software.amazon.smithy.model.traits.EnumTrait
 import software.amazon.smithy.rust.codegen.core.rustlang.RustWriter
 import software.amazon.smithy.rust.codegen.core.rustlang.rustTemplate
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.preludeScope
 import software.amazon.smithy.rust.codegen.core.smithy.RustSymbolProvider
 import software.amazon.smithy.rust.codegen.core.smithy.makeMaybeConstrained
 import software.amazon.smithy.rust.codegen.core.util.expectTrait
@@ -30,7 +31,7 @@ class ConstrainedTraitForEnumGenerator(
 
         val symbol = symbolProvider.toSymbol(shape)
         val name = symbol.name
-        val unconstrainedType = "String"
+        val unconstrainedType = RuntimeType.String.fullyQualifiedName()
 
         writer.rustTemplate(
             """
@@ -38,12 +39,13 @@ class ConstrainedTraitForEnumGenerator(
                 type Unconstrained = $unconstrainedType;
             }
 
-            impl From<$unconstrainedType> for #{MaybeConstrained} {
+            impl #{From}<$unconstrainedType> for #{MaybeConstrained} {
                 fn from(value: $unconstrainedType) -> Self {
                     Self::Unconstrained(value)
                 }
             }
             """,
+            *preludeScope,
             "ConstrainedTrait" to RuntimeType.ConstrainedTrait,
             "MaybeConstrained" to symbol.makeMaybeConstrained(),
         )
diff --git a/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ServerEnumGenerator.kt b/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ServerEnumGenerator.kt
index cc811b80f2..09a0d2d5cd 100644
--- a/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ServerEnumGenerator.kt
+++ b/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ServerEnumGenerator.kt
@@ -8,9 +8,11 @@ import software.amazon.smithy.model.shapes.StringShape
 import software.amazon.smithy.rust.codegen.core.rustlang.Writable
 import software.amazon.smithy.rust.codegen.core.rustlang.rust
 import software.amazon.smithy.rust.codegen.core.rustlang.rustBlock
+import software.amazon.smithy.rust.codegen.core.rustlang.rustBlockTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.rustTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.writable
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType
+import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.preludeScope
 import software.amazon.smithy.rust.codegen.core.smithy.generators.EnumGenerator
 import software.amazon.smithy.rust.codegen.core.smithy.generators.EnumGeneratorContext
 import software.amazon.smithy.rust.codegen.core.smithy.generators.EnumType
@@ -65,7 +67,7 @@ open class ConstrainedEnum(
         }
         rustBlock("impl #T<&str> for ${context.enumName}", RuntimeType.TryFrom) {
             rust("type Error = #T;", constraintViolationSymbol)
-            rustBlock("fn try_from(s: &str) -> Result<Self, <Self as #T<&str>>::Error>", RuntimeType.TryFrom) {
+            rustBlockTemplate("fn try_from(s: &str) -> #{Result}<Self, <Self as #{TryFrom}<&str>>::Error>", *preludeScope) {
                 rustBlock("match s") {
                     context.sortedMembers.forEach { member ->
                         rust("${member.value.dq()} => Ok(${context.enumName}::${member.derivedName()}),")
@@ -78,13 +80,12 @@ open class ConstrainedEnum(
             """
             impl #{TryFrom}<#{String}> for ${context.enumName} {
                 type Error = #{ConstraintViolation};
-                fn try_from(s: #{String}) -> std::result::Result<Self, <Self as #{TryFrom}<String>>::Error> {
+                fn try_from(s: #{String}) -> #{Result}<Self, <Self as #{TryFrom}<#{String}>>::Error> {
                     s.as_str().try_into()
                 }
             }
             """,
-            "String" to RuntimeType.String,
-            "TryFrom" to RuntimeType.TryFrom,
+            *preludeScope,
             "ConstraintViolation" to constraintViolationSymbol,
         )
     }
diff --git a/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/NamingObstacleCourseTest.kt b/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/NamingObstacleCourseTest.kt
new file mode 100644
index 0000000000..b0ae1c3473
--- /dev/null
+++ b/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/NamingObstacleCourseTest.kt
@@ -0,0 +1,32 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package software.amazon.smithy.rust.codegen.server.smithy
+
+import org.junit.jupiter.api.Test
+import software.amazon.smithy.rust.codegen.core.testutil.NamingObstacleCourseTestModels
+import software.amazon.smithy.rust.codegen.server.smithy.testutil.serverIntegrationTest
+
+class NamingObstacleCourseTest {
+    @Test
+    fun `test Rust prelude operation names compile`() {
+        serverIntegrationTest(NamingObstacleCourseTestModels.rustPreludeOperationsModel()) { _, _ -> }
+    }
+
+    @Test
+    fun `test Rust prelude structure names compile`() {
+        serverIntegrationTest(NamingObstacleCourseTestModels.rustPreludeStructsModel()) { _, _ -> }
+    }
+
+    @Test
+    fun `test Rust prelude enum names compile`() {
+        serverIntegrationTest(NamingObstacleCourseTestModels.rustPreludeEnumsModel()) { _, _ -> }
+    }
+
+    @Test
+    fun `test Rust prelude enum variant names compile`() {
+        serverIntegrationTest(NamingObstacleCourseTestModels.rustPreludeEnumVariantsModel()) { _, _ -> }
+    }
+}
diff --git a/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/UnconstrainedShapeSymbolProviderTest.kt b/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/UnconstrainedShapeSymbolProviderTest.kt
index 7c8efe9c17..5f47e10779 100644
--- a/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/UnconstrainedShapeSymbolProviderTest.kt
+++ b/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/UnconstrainedShapeSymbolProviderTest.kt
@@ -98,6 +98,6 @@ class UnconstrainedShapeSymbolProviderTest {
         val structureBShape = model.lookup<StructureShape>("test#StructureB")
 
         unconstrainedShapeSymbolProvider.toSymbol(structureBShape).rustType().render() shouldBe "crate::model::StructureB"
-        unconstrainedShapeSymbolProvider.toSymbol(listAShape).rustType().render() shouldBe "std::vec::Vec<crate::model::StructureB>"
+        unconstrainedShapeSymbolProvider.toSymbol(listAShape).rustType().render() shouldBe "::std::vec::Vec<crate::model::StructureB>"
     }
 }
diff --git a/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedBlobGeneratorTest.kt b/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedBlobGeneratorTest.kt
index 060e0166a4..3a35120f83 100644
--- a/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedBlobGeneratorTest.kt
+++ b/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedBlobGeneratorTest.kt
@@ -117,7 +117,7 @@ class ConstrainedBlobGeneratorTest {
     }
 
     @Test
-    fun `type should not be constructible without using a constructor`() {
+    fun `type should not be constructable without using a constructor`() {
         val model = """
             namespace test
 
@@ -139,6 +139,6 @@ class ConstrainedBlobGeneratorTest {
         ).render()
 
         // Check that the wrapped type is `pub(crate)`.
-        writer.toString() shouldContain "pub struct ConstrainedBlob(pub(crate) aws_smithy_types::Blob);"
+        writer.toString() shouldContain "pub struct ConstrainedBlob(pub(crate) ::aws_smithy_types::Blob);"
     }
 }
diff --git a/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedCollectionGeneratorTest.kt b/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedCollectionGeneratorTest.kt
index cce7da4aa6..3b9e0d4a7b 100644
--- a/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedCollectionGeneratorTest.kt
+++ b/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedCollectionGeneratorTest.kt
@@ -258,7 +258,7 @@ class ConstrainedCollectionGeneratorTest {
     }
 
     @Test
-    fun `type should not be constructible without using a constructor`() {
+    fun `type should not be constructable without using a constructor`() {
         val model =
             """
             namespace test
@@ -276,7 +276,7 @@ class ConstrainedCollectionGeneratorTest {
         render(codegenContext, writer, constrainedCollectionShape)
 
         // Check that the wrapped type is `pub(crate)`.
-        writer.toString() shouldContain "pub struct ConstrainedList(pub(crate) std::vec::Vec<std::string::String>);"
+        writer.toString() shouldContain "pub struct ConstrainedList(pub(crate) ::std::vec::Vec<::std::string::String>);"
     }
 
     private fun render(
diff --git a/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedMapGeneratorTest.kt b/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedMapGeneratorTest.kt
index 0eebb7e36b..cd83336124 100644
--- a/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedMapGeneratorTest.kt
+++ b/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedMapGeneratorTest.kt
@@ -128,7 +128,7 @@ class ConstrainedMapGeneratorTest {
     }
 
     @Test
-    fun `type should not be constructible without using a constructor`() {
+    fun `type should not be constructable without using a constructor`() {
         val model = """
             namespace test
 
@@ -146,7 +146,7 @@ class ConstrainedMapGeneratorTest {
         render(codegenContext, writer, constrainedMapShape)
 
         // Check that the wrapped type is `pub(crate)`.
-        writer.toString() shouldContain "pub struct ConstrainedMap(pub(crate) std::collections::HashMap<std::string::String, std::string::String>);"
+        writer.toString() shouldContain "pub struct ConstrainedMap(pub(crate) ::std::collections::HashMap<::std::string::String, ::std::string::String>);"
     }
 
     private fun render(
diff --git a/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedNumberGeneratorTest.kt b/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedNumberGeneratorTest.kt
index 5a78574c93..3a34c7753c 100644
--- a/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedNumberGeneratorTest.kt
+++ b/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedNumberGeneratorTest.kt
@@ -127,7 +127,7 @@ class ConstrainedNumberGeneratorTest {
 
     @ParameterizedTest
     @ArgumentsSource(NoStructuralConstructorTestProvider::class)
-    fun `type should not be constructible without using a constructor`(args: Triple<String, String, String>) {
+    fun `type should not be constructable without using a constructor`(args: Triple<String, String, String>) {
         val (smithyType, shapeName, rustType) = args
         val model = """
             namespace test
diff --git a/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedStringGeneratorTest.kt b/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedStringGeneratorTest.kt
index 62a7d061c3..eb0ba5ed34 100644
--- a/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedStringGeneratorTest.kt
+++ b/codegen-server/src/test/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ConstrainedStringGeneratorTest.kt
@@ -131,7 +131,7 @@ class ConstrainedStringGeneratorTest {
     }
 
     @Test
-    fun `type should not be constructible without using a constructor`() {
+    fun `type should not be constructable without using a constructor`() {
         val model = """
             namespace test
 
@@ -153,7 +153,7 @@ class ConstrainedStringGeneratorTest {
         ).render()
 
         // Check that the wrapped type is `pub(crate)`.
-        writer.toString() shouldContain "pub struct ConstrainedString(pub(crate) std::string::String);"
+        writer.toString() shouldContain "pub struct ConstrainedString(pub(crate) ::std::string::String);"
     }
 
     @Test