Apply suggestions from code review

Co-authored-by: Fabrizio Ferri-Benedetti <[email protected]>

content/en/docs/concepts/instrumentation/_index.md

@@ -13,20 +13,19 @@ from the system's components must emit [traces](/docs/concepts/signals/traces/),
 [logs](/docs/concepts/signals/logs/).
 
 OpenTelemetry provides [APIs and SDKs for eleven languages](/docs/languages) to
-facilitate the process of instrumenting your code. Among others it provides the
-following benefits:
+facilitate instrumenting your code. Among others it provides the following benefits:
 
 - Each language-specific implementation of the API and SDK follows the
   requirements and expectations of the
   [OpenTelemetry specification](/docs/specs/otel/)
 - Libraries can leverage the OpenTelemetry API as a dependency, which will have
   no impact on applications using that library, unless the OpenTelemetry SDK is
   imported.
-- For each [signal](/docs/concepts/signals) (traces, metrics, logs) you will
-  find methods to create them, process them and export them.
-- With [context propagation](/docs/concepts/context-propagation) being built
-  into the implementations, you can correlate signals, regardless of where they
-  are generated
+- For each [signal](/docs/concepts/signals) (traces, metrics, logs) you have
+  several methods at your disposals to create, process, and export them.
+- With [context propagation](/docs/concepts/context-propagation) built into
+   the implementations, you can correlate signals regardless of where they
+   are generated.
 - [Resources](/docs/concepts/resources) and
   [Instrumentation Scopes](/docs/concepts/instrumentation-scope) allow grouping
   of signals, by different entities.
@@ -44,9 +43,9 @@ for those without such an integration.
 
 As [ops](/docs/getting-started/ops/) you will find
 [zero-code](/docs/concepts/instrumentation/zero-code) solutions for many
-languages, that will add instrumentation to an application without you knowing
-about the inner workings of that application.
+languages that add instrumentation to an application without having to know
+about the inner workings of that application or service.
 
-For most languages it is possible to use both approaches at the same time, so
+For most languages, you can use both approaches at the same time, so that
 you can start with a zero-code approach to gain insights quickly and then update
-your code with embedded more granular observability.
+your code with embedded, more granular observability you add manually.

content/en/docs/concepts/instrumentation/zero-code.md

@@ -1,33 +1,37 @@
 ---
 title: Zero-Code
 description: >-
-  Learn how to add observability to an application without the need to touch the
+  Learn how to add observability to an application without the need to write more
   code
 weight: 10
 aliases: [automatic]
 ---
 
-As [ops](/docs/getting-started/ops/) you may want to add observability to an
-application (or to many applications!) without being able to add instrumentation
-to the code base. Or, you may be looking for a way to quickly gain some basic
-observability for an application, before diving into learning how to use the
-OpenTelemetry API & SDK for
+As [ops](/docs/getting-started/ops/) you might want to add observability to one
+or more applications without having to edit the source, probably because you can't
+or you're not allowed to. In other cases, you might be looking for a way to quickly
+gain some OTel observability for a service before diving into learning how to use
+the OpenTelemetry API & SDK for
 [code-based instrumentation](/docs/concepts/instrumentation/code-based).
 
-In those cases you will be able to leverage language specific zero-code
-solutions, that use mechanisms like byte-code instrumentation, monkey patching
-or eBPF, to inject calls to the OpenTelemetry API & SDK into your application.
+In all the previous cases, you can leverage language specific zero-code
+solutions, which use mechanisms like bytecode instrumentation, monkey patching,
+or eBPF to inject calls to the OpenTelemetry API and SDK into your application.
 
-While the underlying mechanism depends on the language, at a minimum this will
-add the OpenTelemetry API and SDK capabilities to your application. Additionally
-they may add a set of
+While the underlying mechanism depends on the language, zero-code
+instrumentation adds the OpenTelemetry API and SDK capabilities to your
+application with almost no effort. In addition, you can use the same process
+to add a set of
 [Instrumentation Libraries](/docs/concepts/instrumentation/libraries) and
 [exporter](/docs/concepts/components/#exporters) dependencies.
 
-Configuration is available via environment variables and possibly language
-specific means such as system properties in Java. At a minimum, a service name
-must be configured to identify the service being instrumented. A variety of
-other configuration options are available and may include:
+You can configure zero-code instrumentation through environment variables
+and other language-specific mechanisms, such as system properties or
+arguments passed to initialization methods. To get started, you only need
+a service name configured so that you can identify the service in the
+observability backend of your choice.
+
+Other configuration options are available, including:
 
 - Data source specific configuration
 - Exporter configuration