diff --git a/admin/test/utils.go b/admin/test/utils.go
index 26391c41ee03..2f86c15c38d0 100644
--- a/admin/test/utils.go
+++ b/admin/test/utils.go
@@ -68,9 +68,9 @@ func RunRegisterTests(t *testing.T, ec ExpectedStatusCodes) {
 		server.Serve(lis)
 	}()
 
-	conn, err := grpc.Dial(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
+	conn, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
 	if err != nil {
-		t.Fatalf("cannot connect to server: %v", err)
+		t.Fatalf("grpc.NewClient(%q) = %v", lis.Addr().String(), err)
 	}
 
 	t.Run("channelz", func(t *testing.T) {
diff --git a/balancer/grpclb/grpclb_remote_balancer.go b/balancer/grpclb/grpclb_remote_balancer.go
index 506fae0d4e2d..f2df56120fec 100644
--- a/balancer/grpclb/grpclb_remote_balancer.go
+++ b/balancer/grpclb/grpclb_remote_balancer.go
@@ -260,10 +260,11 @@ func (lb *lbBalancer) newRemoteBalancerCCWrapper() error {
 	// The grpclb server addresses will set field ServerName, and creds will
 	// receive ServerName as authority.
 	target := lb.manualResolver.Scheme() + ":///grpclb.subClientConn"
-	cc, err := grpc.Dial(target, dopts...)
+	cc, err := grpc.NewClient(target, dopts...)
 	if err != nil {
-		return fmt.Errorf("grpc.Dial(%s): %v", target, err)
+		return fmt.Errorf("grpc.NewClient(%s): %v", target, err)
 	}
+	cc.Connect()
 	ccw := &remoteBalancerCCWrapper{
 		cc:      cc,
 		lb:      lb,
diff --git a/benchmark/benchmark.go b/benchmark/benchmark.go
index 0d4558f4ec80..5c3dcd51db9d 100644
--- a/benchmark/benchmark.go
+++ b/benchmark/benchmark.go
@@ -340,10 +340,10 @@ func NewClientConn(addr string, opts ...grpc.DialOption) *grpc.ClientConn {
 }
 
 // NewClientConnWithContext creates a gRPC client connection to addr using ctx.
-func NewClientConnWithContext(ctx context.Context, addr string, opts ...grpc.DialOption) *grpc.ClientConn {
-	conn, err := grpc.DialContext(ctx, addr, opts...)
+func NewClientConnWithContext(_ context.Context, addr string, opts ...grpc.DialOption) *grpc.ClientConn {
+	conn, err := grpc.NewClient(addr, opts...)
 	if err != nil {
-		logger.Fatalf("NewClientConn(%q) failed to create a ClientConn: %v", addr, err)
+		logger.Fatalf("grpc.NewClient(%q) = %v", addr, err)
 	}
 	return conn
 }
diff --git a/credentials/alts/internal/handshaker/service/service.go b/credentials/alts/internal/handshaker/service/service.go
index fbfde5d047fe..e0a1afc118cc 100644
--- a/credentials/alts/internal/handshaker/service/service.go
+++ b/credentials/alts/internal/handshaker/service/service.go
@@ -50,7 +50,7 @@ func Dial(hsAddress string) (*grpc.ClientConn, error) {
 		// Disable the service config to avoid unnecessary TXT record lookups that
 		// cause timeouts with some versions of systemd-resolved.
 		var err error
-		hsConn, err = grpc.Dial(hsAddress, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithDisableServiceConfig())
+		hsConn, err = grpc.NewClient(hsAddress, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithDisableServiceConfig())
 		if err != nil {
 			return nil, err
 		}
diff --git a/internal/stubserver/stubserver.go b/internal/stubserver/stubserver.go
index ed23930b4e41..f290d97e984f 100644
--- a/internal/stubserver/stubserver.go
+++ b/internal/stubserver/stubserver.go
@@ -225,10 +225,11 @@ func (ss *StubServer) StartClient(dopts ...grpc.DialOption) error {
 		opts = append(opts, grpc.WithResolvers(ss.R))
 	}
 
-	cc, err := grpc.Dial(ss.Target, opts...)
+	cc, err := grpc.NewClient(ss.Target, opts...)
 	if err != nil {
-		return fmt.Errorf("grpc.Dial(%q) = %v", ss.Target, err)
+		return fmt.Errorf("grpc.NewClient(%q) = %v", ss.Target, err)
 	}
+	cc.Connect()
 	ss.CC = cc
 	if ss.R != nil {
 		ss.R.UpdateState(resolver.State{Addresses: []resolver.Address{{Addr: ss.Address}}})
diff --git a/interop/alts/client/client.go b/interop/alts/client/client.go
index aef601ff885b..d46280282efe 100644
--- a/interop/alts/client/client.go
+++ b/interop/alts/client/client.go
@@ -48,9 +48,9 @@ func main() {
 	}
 	altsTC := alts.NewClientCreds(opts)
 	// Block until the server is ready.
-	conn, err := grpc.Dial(*serverAddr, grpc.WithTransportCredentials(altsTC), grpc.WithBlock())
+	conn, err := grpc.NewClient(*serverAddr, grpc.WithTransportCredentials(altsTC))
 	if err != nil {
-		logger.Fatalf("gRPC Client: failed to dial the server at %v: %v", *serverAddr, err)
+		logger.Fatalf("grpc.NewClient(%q) = %v", *serverAddr, err)
 	}
 	defer conn.Close()
 	grpcClient := testgrpc.NewTestServiceClient(conn)
diff --git a/interop/client/client.go b/interop/client/client.go
index b088451cd203..249dd637ab9d 100644
--- a/interop/client/client.go
+++ b/interop/client/client.go
@@ -280,7 +280,7 @@ func main() {
 	}
 	conn, err := grpc.NewClient(serverAddr, opts...)
 	if err != nil {
-		logger.Fatalf("Fail to dial: %v", err)
+		logger.Fatalf("grpc.NewClient(%q) = %v", serverAddr, err)
 	}
 	defer conn.Close()
 	tc := testgrpc.NewTestServiceClient(conn)
diff --git a/interop/grpclb_fallback/client_linux.go b/interop/grpclb_fallback/client_linux.go
index 9498182493b1..47c16ad3aa04 100644
--- a/interop/grpclb_fallback/client_linux.go
+++ b/interop/grpclb_fallback/client_linux.go
@@ -112,9 +112,9 @@ func createTestConn() *grpc.ClientConn {
 	default:
 		errorLog.Fatalf("Invalid --custom_credentials_type:%v", *customCredentialsType)
 	}
-	conn, err := grpc.Dial(*serverURI, opts...)
+	conn, err := grpc.NewClient(*serverURI, opts...)
 	if err != nil {
-		errorLog.Fatalf("Fail to dial: %v", err)
+		errorLog.Fatalf("grpc.NewClient(%q) = %v", *serverURI, err)
 	}
 	return conn
 }
diff --git a/interop/http2/negative_http2_client.go b/interop/http2/negative_http2_client.go
index 771845309c29..35c7b54a4444 100644
--- a/interop/http2/negative_http2_client.go
+++ b/interop/http2/negative_http2_client.go
@@ -133,9 +133,9 @@ func main() {
 	serverAddr := net.JoinHostPort(*serverHost, strconv.Itoa(*serverPort))
 	var opts []grpc.DialOption
 	opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials()))
-	conn, err := grpc.Dial(serverAddr, opts...)
+	conn, err := grpc.NewClient(serverAddr, opts...)
 	if err != nil {
-		logger.Fatalf("Fail to dial: %v", err)
+		logger.Fatalf("grpc.NewClient(%q) = %v", serverAddr, err)
 	}
 	defer conn.Close()
 	tc := testgrpc.NewTestServiceClient(conn)
diff --git a/interop/observability/client/client.go b/interop/observability/client/client.go
index 0a07994bb853..0850e706ed44 100644
--- a/interop/observability/client/client.go
+++ b/interop/observability/client/client.go
@@ -57,9 +57,9 @@ func main() {
 	if *serverPort != 0 {
 		serverAddr = net.JoinHostPort(*serverHost, strconv.Itoa(*serverPort))
 	}
-	conn, err := grpc.Dial(serverAddr, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	conn, err := grpc.NewClient(serverAddr, grpc.WithTransportCredentials(insecure.NewCredentials()))
 	if err != nil {
-		log.Fatalf("Fail to dial: %v", err)
+		log.Fatalf("grpc.NewClient(%q) = %v", serverAddr, err)
 	}
 	defer conn.Close()
 	tc := testgrpc.NewTestServiceClient(conn)
diff --git a/interop/stress/client/main.go b/interop/stress/client/main.go
index 8b22716bf0d4..457ff54c05c6 100644
--- a/interop/stress/client/main.go
+++ b/interop/stress/client/main.go
@@ -319,7 +319,7 @@ func newConn(address string, useTLS, testCA bool, tlsServerName string) (*grpc.C
 	} else {
 		opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials()))
 	}
-	return grpc.Dial(address, opts...)
+	return grpc.NewClient(address, opts...)
 }
 
 func main() {
diff --git a/interop/stress/metrics_client/main.go b/interop/stress/metrics_client/main.go
index f6e16abddad2..84b4e6b508bb 100644
--- a/interop/stress/metrics_client/main.go
+++ b/interop/stress/metrics_client/main.go
@@ -75,9 +75,9 @@ func main() {
 		logger.Fatal("-metrics_server_address is unset")
 	}
 
-	conn, err := grpc.Dial(*metricsServerAddress, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	conn, err := grpc.NewClient(*metricsServerAddress, grpc.WithTransportCredentials(insecure.NewCredentials()))
 	if err != nil {
-		logger.Fatalf("cannot connect to metrics server: %v", err)
+		logger.Fatalf("grpc.NewClient(%q) = %v", metricsServerAddress, err)
 	}
 	defer conn.Close()
 
diff --git a/interop/xds/client/client.go b/interop/xds/client/client.go
index e74831add335..d3ab7eb64a64 100644
--- a/interop/xds/client/client.go
+++ b/interop/xds/client/client.go
@@ -437,9 +437,9 @@ func main() {
 
 	clients := make([]testgrpc.TestServiceClient, *numChannels)
 	for i := 0; i < *numChannels; i++ {
-		conn, err := grpc.Dial(*server, grpc.WithTransportCredentials(creds))
+		conn, err := grpc.NewClient(*server, grpc.WithTransportCredentials(creds))
 		if err != nil {
-			logger.Fatalf("Fail to dial: %v", err)
+			logger.Fatalf("grpc.NewClient(%q) = %v", *server, err)
 		}
 		defer conn.Close()
 		clients[i] = testgrpc.NewTestServiceClient(conn)
diff --git a/interop/xds_federation/client.go b/interop/xds_federation/client.go
index 1d210369f089..d7e9fd3ec637 100644
--- a/interop/xds_federation/client.go
+++ b/interop/xds_federation/client.go
@@ -95,7 +95,7 @@ func main() {
 		}
 		cc, err := grpc.NewClient(uris[i], opts...)
 		if err != nil {
-			logger.Fatalf("Fail to dial %v: %v", uris[i], err)
+			logger.Fatalf("grpc.NewClient(%q) = %v", uris[i], err)
 		}
 		defer cc.Close()
 		clients = append(clients, clientConfig{
diff --git a/profiling/cmd/remote.go b/profiling/cmd/remote.go
index b75c3e3bb33b..e21ef146211f 100644
--- a/profiling/cmd/remote.go
+++ b/profiling/cmd/remote.go
@@ -79,9 +79,9 @@ func remoteCommand() error {
 	}
 
 	logger.Infof("dialing %s", *flagAddress)
-	cc, err := grpc.Dial(*flagAddress, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	cc, err := grpc.NewClient(*flagAddress, grpc.WithTransportCredentials(insecure.NewCredentials()))
 	if err != nil {
-		logger.Errorf("cannot dial %s: %v", *flagAddress, err)
+		logger.Fatalf("grpc.NewClient(%q) = %v", *flagAddress, err)
 		return err
 	}
 	defer cc.Close()
diff --git a/resolver/manual/manual.go b/resolver/manual/manual.go
index 09e864a89d35..8400b5f2b659 100644
--- a/resolver/manual/manual.go
+++ b/resolver/manual/manual.go
@@ -110,7 +110,7 @@ func (r *Resolver) UpdateState(s resolver.State) {
 	defer r.mu.Unlock()
 	var err error
 	if r.CC == nil {
-		panic("cannot update state as grpc.Dial with resolver has not been called")
+		panic("cannot update state as channel has not exited IDLE state")
 	}
 	err = r.CC.UpdateState(s)
 	r.lastSeenState = &s
@@ -122,7 +122,7 @@ func (r *Resolver) ReportError(err error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	if r.CC == nil {
-		panic("cannot report error as grpc.Dial with resolver has not been called")
+		panic("cannot report error as channel has not exited IDLE state")
 	}
 	r.CC.ReportError(err)
 }
diff --git a/resolver/manual/manual_test.go b/resolver/manual/manual_test.go
index 2d089268b778..9f1701b10053 100644
--- a/resolver/manual/manual_test.go
+++ b/resolver/manual/manual_test.go
@@ -38,7 +38,7 @@ func TestResolver(t *testing.T) {
 
 	t.Run("update_state_panics", func(t *testing.T) {
 		defer func() {
-			want := "cannot update state as grpc.Dial with resolver has not been called"
+			want := "cannot update state as channel has not exited IDLE state"
 			if r := recover(); r != want {
 				t.Errorf("expected panic %q, got %q", want, r)
 			}
@@ -50,7 +50,7 @@ func TestResolver(t *testing.T) {
 	})
 	t.Run("report_error_panics", func(t *testing.T) {
 		defer func() {
-			want := "cannot report error as grpc.Dial with resolver has not been called"
+			want := "cannot report error as channel has not exited IDLE state"
 			if r := recover(); r != want {
 				t.Errorf("expected panic %q, got %q", want, r)
 			}
diff --git a/test/goaway_test.go b/test/goaway_test.go
index 5fe7c9fd7334..076412da7c20 100644
--- a/test/goaway_test.go
+++ b/test/goaway_test.go
@@ -677,6 +677,7 @@ func (s) TestGoAwayStreamIDSmallerThanCreatedStreams(t *testing.T) {
 	}
 	defer cc.Close()
 	cc.Connect()
+
 	ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
 	defer cancel()
 
diff --git a/test/xds/xds_client_certificate_providers_test.go b/test/xds/xds_client_certificate_providers_test.go
index 0c562f4e78b5..7f5ade582663 100644
--- a/test/xds/xds_client_certificate_providers_test.go
+++ b/test/xds/xds_client_certificate_providers_test.go
@@ -169,7 +169,7 @@ func (s) TestClientSideXDS_WithNoCertificateProvidersInBootstrap_Failure(t *test
 	// Create a ClientConn and ensure that it moves to TRANSIENT_FAILURE.
 	cc, err := grpc.NewClient(fmt.Sprintf("xds:///%s", serviceName), grpc.WithTransportCredentials(creds), grpc.WithResolvers(resolverBuilder))
 	if err != nil {
-		t.Fatalf("failed to create a client for server: %v", err)
+		t.Fatalf("grpc.NewClient() failed: %v", err)
 	}
 	defer cc.Close()
 	cc.Connect()
diff --git a/xds/internal/test/e2e/e2e.go b/xds/internal/test/e2e/e2e.go
index 30b125b787a1..2869a9300f36 100644
--- a/xds/internal/test/e2e/e2e.go
+++ b/xds/internal/test/e2e/e2e.go
@@ -71,7 +71,7 @@ func newClient(target, binaryPath, bootstrap string, logger io.Writer, flags ...
 	)
 	cmd.Start()
 
-	cc, err := grpc.Dial(fmt.Sprintf("localhost:%d", clientStatsPort), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithDefaultCallOptions(grpc.WaitForReady(true)))
+	cc, err := grpc.NewClient(fmt.Sprintf("localhost:%d", clientStatsPort), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithDefaultCallOptions(grpc.WaitForReady(true)))
 	if err != nil {
 		return nil, err
 	}