Apply suggestions from code review

Co-authored-by: David Stansby <[email protected]>

Author: normanrz

docs/user-guide/arrays.rst

@@ -580,8 +580,8 @@ With Zarr format 3, a new sharding feature has been added to address this issue.
 
 With sharding, multiple chunks can be stored in a single storage object (e.g. a file).
 Within a shard, chunks are compressed and serialized separately.
-This allows to read individual chunks independently.
-However, when writing data, a full shard must be written for optimal performance and to
+This allows individual chunks to be read independently.
+However, when writing data, a full shard must be written in one go for optimal performance and to
 avoid concurrency issues.
 That means that shards are the units of writing and chunks are the units of reading.
 Users need to configure the chunk and shard shapes accordingly.
@@ -607,7 +607,7 @@ Sharded arrays can be created by providing the ``shards`` parameter to :func:`za
   Chunks Initialized : 100
 
 In this example a shard shape of (1000, 1000) and a chunk shape of (100, 100) is used.
-This means that 10*10 chunks are stored in each shard.
+This means that 10*10 chunks are stored in each shard, and there are 10*10 shards in total.
 
 Missing features in 3.0
 -----------------------

docs/user-guide/performance.rst

@@ -69,14 +69,14 @@ Sharding
 If you have large arrays but need small chunks to efficiently access the data, you can
 use sharding. Sharding provides a mechanism to store multiple chunks in a single
 storage object or file. This can be useful because traditional file systems and object
-storage systems may have issues with many small files.
+storage systems may have issues storing and accessing many files.
 
 Picking a good combination of chunk shape and shard shape is important for performance.
 The chunk shape determines what unit of your data can be read independently, while the
 shard shape determines what unit of your data can be written efficiently.
 
 For an example, consider you have a 100 GB array and need to read small chunks of 1 MB.
-Without sharding, each chunk would be one file resulting in 10000 files. That can
+Without sharding, each chunk would be one file resulting in 100,000 files. That can
 already cause performance issues on some file systems.
 With sharding, you could use a shard size of 1 GB. This would result in 1000 chunks per
 file and 100 files in total, which seems manageable for most storage systems.