diff --git a/.github/workflows/docs.yaml b/.github/workflows/docs.yaml
index a0a6409864a060fdd69796f36ac38ec6715e2982..8f8c8c5d06238147d0d6942d70c089355da1ea80 100644
--- a/.github/workflows/docs.yaml
+++ b/.github/workflows/docs.yaml
@@ -15,18 +15,14 @@ jobs:
       - name: Copy assets
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          SOURCE_VER: ${{ 'v0.1.1' }}
-          KUSTOMIZE_VER: ${{ 'v0.1.1' }}
-          HELM_VER: ${{ 'v0.1.2' }}
-          NOTIFICATION_VER: ${{ 'v0.1.1' }}
         run: |
           controller_version() {
-            sed -n "s/\(.*$1\/.*?ref=\)//p;n" "manifests/bases/$1/kustomization.yaml"
+            sed -n "s/.*$1\/archive\/\(.*\).zip.*/\1/p;n" manifests/bases/$1/kustomization.yaml
           }
 
           {
             # source-controller CRDs
-            # SOURCE_VER=$(controller_version source-controller)
+            SOURCE_VER=$(controller_version source-controller)
             curl -# -Lf "https://raw.githubusercontent.com/fluxcd/source-controller/$SOURCE_VER/docs/api/source.md" > docs/components/source/api.md
             curl -# -Lf "https://raw.githubusercontent.com/fluxcd/source-controller/$SOURCE_VER/docs/spec/v1beta1/gitrepositories.md" > docs/components/source/gitrepositories.md
             curl -# -Lf "https://raw.githubusercontent.com/fluxcd/source-controller/$SOURCE_VER/docs/spec/v1beta1/helmrepositories.md" > docs/components/source/helmrepositories.md
@@ -36,21 +32,21 @@ jobs:
 
           {
             # kustomize-controller CRDs
-            # KUSTOMIZE_VER=$(controller_version kustomize-controller)
+            KUSTOMIZE_VER=$(controller_version kustomize-controller)
             curl -# -Lf "https://raw.githubusercontent.com/fluxcd/kustomize-controller/$KUSTOMIZE_VER/docs/api/kustomize.md" > docs/components/kustomize/api.md
             curl -# -Lf "https://raw.githubusercontent.com/fluxcd/kustomize-controller/$KUSTOMIZE_VER/docs/spec/v1beta1/kustomization.md" > docs/components/kustomize/kustomization.md
           }
 
           {
             # helm-controller CRDs
-            # HELM_VER=$(controller_version helm-controller)
+            HELM_VER=$(controller_version helm-controller)
             curl -# -Lf "https://raw.githubusercontent.com/fluxcd/helm-controller/$HELM_VER/docs/api/helmrelease.md" > docs/components/helm/api.md
             curl -# -Lf "https://raw.githubusercontent.com/fluxcd/helm-controller/$HELM_VER/docs/spec/v2beta1/helmreleases.md" > docs/components/helm/helmreleases.md
           }
 
           {
             # notification-controller CRDs
-            # NOTIFICATION_VER=$(controller_version notification-controller)
+            NOTIFICATION_VER=$(controller_version notification-controller)
             curl -# -Lf "https://raw.githubusercontent.com/fluxcd/notification-controller/$NOTIFICATION_VER/docs/api/notification.md" > docs/components/notification/api.md
             curl -# -Lf "https://raw.githubusercontent.com/fluxcd/notification-controller/$NOTIFICATION_VER/docs/spec/v1beta1/event.md" > docs/components/notification/event.md
             curl -# -Lf "https://raw.githubusercontent.com/fluxcd/notification-controller/$NOTIFICATION_VER/docs/spec/v1beta1/alert.md" > docs/components/notification/alert.md
diff --git a/.github/workflows/update.yml b/.github/workflows/update.yml
index 5ca972e8935fdbb2f5a274af6eeca777878356a8..42bd191b9fc33a2ee6c9e3bf69586eb34aa2814a 100644
--- a/.github/workflows/update.yml
+++ b/.github/workflows/update.yml
@@ -19,7 +19,7 @@ jobs:
 
           bump_version() {
             local RELEASE_VERSION=$(curl -s https://api.github.com/repos/fluxcd/$1/releases | jq -r 'sort_by(.published_at) | .[-1] | .tag_name')
-            local CURRENT_VERSION=$(sed -n "s/\(.*$1\/.*?ref=\)//p;n" "manifests/bases/$1/kustomization.yaml")
+            local CURRENT_VERSION=$(sed -n "s/.*$1\/archive\/\(.*\).zip.*/\1/p;n" manifests/bases/$1/kustomization.yaml)
 
             if [[ "${RELEASE_VERSION}" != "${CURRENT_VERSION}" ]]; then
               # bump kustomize
diff --git a/cmd/gotk/bootstrap.go b/cmd/gotk/bootstrap.go
index 970275730d35283b9bc475e9ed11d3930b40bbf1..2dce249aa985ccc01ec1aee38ded69e5d2a902f5 100644
--- a/cmd/gotk/bootstrap.go
+++ b/cmd/gotk/bootstrap.go
@@ -246,13 +246,15 @@ func applySyncManifests(ctx context.Context, kubeClient client.Client, name, nam
 
 	logger.Waitingf("waiting for cluster sync")
 
+	var gitRepository sourcev1.GitRepository
 	if err := wait.PollImmediate(pollInterval, timeout,
-		isGitRepositoryReady(ctx, kubeClient, name, namespace)); err != nil {
+		isGitRepositoryReady(ctx, kubeClient, types.NamespacedName{Name: name, Namespace: namespace}, &gitRepository)); err != nil {
 		return err
 	}
 
+	var kustomization kustomizev1.Kustomization
 	if err := wait.PollImmediate(pollInterval, timeout,
-		isKustomizationReady(ctx, kubeClient, name, namespace)); err != nil {
+		isKustomizationReady(ctx, kubeClient, types.NamespacedName{Name: name, Namespace: namespace}, &kustomization)); err != nil {
 		return err
 	}
 
diff --git a/cmd/gotk/create_alert.go b/cmd/gotk/create_alert.go
index 6e7cbd535abec66bd4e945d201f02d97169ffdee..9a943b210e6eefc08ffef3749c32fa6e1f589469 100644
--- a/cmd/gotk/create_alert.go
+++ b/cmd/gotk/create_alert.go
@@ -61,7 +61,7 @@ func init() {
 
 func createAlertCmdRun(cmd *cobra.Command, args []string) error {
 	if len(args) < 1 {
-		return fmt.Errorf("alert name is required")
+		return fmt.Errorf("Alert name is required")
 	}
 	name := args[0]
 
@@ -92,7 +92,7 @@ func createAlertCmdRun(cmd *cobra.Command, args []string) error {
 	}
 
 	if !export {
-		logger.Generatef("generating alert")
+		logger.Generatef("generating Alert")
 	}
 
 	alert := notificationv1.Alert{
@@ -123,23 +123,23 @@ func createAlertCmdRun(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	logger.Actionf("applying alert")
-	if err := upsertAlert(ctx, kubeClient, alert); err != nil {
+	logger.Actionf("applying Alert")
+	namespacedName, err := upsertAlert(ctx, kubeClient, &alert)
+	if err != nil {
 		return err
 	}
 
-	logger.Waitingf("waiting for reconciliation")
+	logger.Waitingf("waiting for Alert reconciliation")
 	if err := wait.PollImmediate(pollInterval, timeout,
-		isAlertReady(ctx, kubeClient, name, namespace)); err != nil {
+		isAlertReady(ctx, kubeClient, namespacedName, &alert)); err != nil {
 		return err
 	}
-
-	logger.Successf("alert %s is ready", name)
-
+	logger.Successf("Alert %s is ready", name)
 	return nil
 }
 
-func upsertAlert(ctx context.Context, kubeClient client.Client, alert notificationv1.Alert) error {
+func upsertAlert(ctx context.Context, kubeClient client.Client,
+	alert *notificationv1.Alert) (types.NamespacedName, error) {
 	namespacedName := types.NamespacedName{
 		Namespace: alert.GetNamespace(),
 		Name:      alert.GetName(),
@@ -149,35 +149,30 @@ func upsertAlert(ctx context.Context, kubeClient client.Client, alert notificati
 	err := kubeClient.Get(ctx, namespacedName, &existing)
 	if err != nil {
 		if errors.IsNotFound(err) {
-			if err := kubeClient.Create(ctx, &alert); err != nil {
-				return err
+			if err := kubeClient.Create(ctx, alert); err != nil {
+				return namespacedName, err
 			} else {
-				logger.Successf("alert created")
-				return nil
+				logger.Successf("Alert created")
+				return namespacedName, nil
 			}
 		}
-		return err
+		return namespacedName, err
 	}
 
 	existing.Labels = alert.Labels
 	existing.Spec = alert.Spec
 	if err := kubeClient.Update(ctx, &existing); err != nil {
-		return err
+		return namespacedName, err
 	}
-
-	logger.Successf("alert updated")
-	return nil
+	alert = &existing
+	logger.Successf("Alert updated")
+	return namespacedName, nil
 }
 
-func isAlertReady(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isAlertReady(ctx context.Context, kubeClient client.Client,
+	namespacedName types.NamespacedName, alert *notificationv1.Alert) wait.ConditionFunc {
 	return func() (bool, error) {
-		var alert notificationv1.Alert
-		namespacedName := types.NamespacedName{
-			Namespace: namespace,
-			Name:      name,
-		}
-
-		err := kubeClient.Get(ctx, namespacedName, &alert)
+		err := kubeClient.Get(ctx, namespacedName, alert)
 		if err != nil {
 			return false, err
 		}
diff --git a/cmd/gotk/create_alertprovider.go b/cmd/gotk/create_alertprovider.go
index a5e8b5318bf3611562bf116592d45a85a8d15634..9c28782ea6e931f12d32be85a2baba9289472913 100644
--- a/cmd/gotk/create_alertprovider.go
+++ b/cmd/gotk/create_alertprovider.go
@@ -71,12 +71,12 @@ func init() {
 
 func createAlertProviderCmdRun(cmd *cobra.Command, args []string) error {
 	if len(args) < 1 {
-		return fmt.Errorf("provider name is required")
+		return fmt.Errorf("Provider name is required")
 	}
 	name := args[0]
 
 	if apType == "" {
-		return fmt.Errorf("type is required")
+		return fmt.Errorf("Provider type is required")
 	}
 
 	sourceLabels, err := parseLabels()
@@ -85,10 +85,10 @@ func createAlertProviderCmdRun(cmd *cobra.Command, args []string) error {
 	}
 
 	if !export {
-		logger.Generatef("generating provider")
+		logger.Generatef("generating Provider")
 	}
 
-	alertProvider := notificationv1.Provider{
+	provider := notificationv1.Provider{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      name,
 			Namespace: namespace,
@@ -103,13 +103,13 @@ func createAlertProviderCmdRun(cmd *cobra.Command, args []string) error {
 	}
 
 	if apSecretRef != "" {
-		alertProvider.Spec.SecretRef = &corev1.LocalObjectReference{
+		provider.Spec.SecretRef = &corev1.LocalObjectReference{
 			Name: apSecretRef,
 		}
 	}
 
 	if export {
-		return exportAlertProvider(alertProvider)
+		return exportAlertProvider(provider)
 	}
 
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
@@ -120,66 +120,63 @@ func createAlertProviderCmdRun(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	logger.Actionf("applying provider")
-	if err := upsertAlertProvider(ctx, kubeClient, alertProvider); err != nil {
+	logger.Actionf("applying Provider")
+	namespacedName, err := upsertAlertProvider(ctx, kubeClient, &provider)
+	if err != nil {
 		return err
 	}
 
-	logger.Waitingf("waiting for reconciliation")
+	logger.Waitingf("waiting for Provider reconciliation")
 	if err := wait.PollImmediate(pollInterval, timeout,
-		isAlertProviderReady(ctx, kubeClient, name, namespace)); err != nil {
+		isAlertProviderReady(ctx, kubeClient, namespacedName, &provider)); err != nil {
 		return err
 	}
 
-	logger.Successf("provider %s is ready", name)
+	logger.Successf("Provider %s is ready", name)
 
 	return nil
 }
 
-func upsertAlertProvider(ctx context.Context, kubeClient client.Client, alertProvider notificationv1.Provider) error {
+func upsertAlertProvider(ctx context.Context, kubeClient client.Client,
+	provider *notificationv1.Provider) (types.NamespacedName, error) {
 	namespacedName := types.NamespacedName{
-		Namespace: alertProvider.GetNamespace(),
-		Name:      alertProvider.GetName(),
+		Namespace: provider.GetNamespace(),
+		Name:      provider.GetName(),
 	}
 
 	var existing notificationv1.Provider
 	err := kubeClient.Get(ctx, namespacedName, &existing)
 	if err != nil {
 		if errors.IsNotFound(err) {
-			if err := kubeClient.Create(ctx, &alertProvider); err != nil {
-				return err
+			if err := kubeClient.Create(ctx, provider); err != nil {
+				return namespacedName, err
 			} else {
-				logger.Successf("provider created")
-				return nil
+				logger.Successf("Provider created")
+				return namespacedName, nil
 			}
 		}
-		return err
+		return namespacedName, err
 	}
 
-	existing.Labels = alertProvider.Labels
-	existing.Spec = alertProvider.Spec
+	existing.Labels = provider.Labels
+	existing.Spec = provider.Spec
 	if err := kubeClient.Update(ctx, &existing); err != nil {
-		return err
+		return namespacedName, err
 	}
-
-	logger.Successf("provider updated")
-	return nil
+	provider = &existing
+	logger.Successf("Provider updated")
+	return namespacedName, nil
 }
 
-func isAlertProviderReady(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isAlertProviderReady(ctx context.Context, kubeClient client.Client,
+	namespacedName types.NamespacedName, provider *notificationv1.Provider) wait.ConditionFunc {
 	return func() (bool, error) {
-		var alertProvider notificationv1.Provider
-		namespacedName := types.NamespacedName{
-			Namespace: namespace,
-			Name:      name,
-		}
-
-		err := kubeClient.Get(ctx, namespacedName, &alertProvider)
+		err := kubeClient.Get(ctx, namespacedName, provider)
 		if err != nil {
 			return false, err
 		}
 
-		if c := meta.GetCondition(alertProvider.Status.Conditions, meta.ReadyCondition); c != nil {
+		if c := meta.GetCondition(provider.Status.Conditions, meta.ReadyCondition); c != nil {
 			switch c.Status {
 			case corev1.ConditionTrue:
 				return true, nil
diff --git a/cmd/gotk/create_helmrelease.go b/cmd/gotk/create_helmrelease.go
index 7dd6cbeabf2714c64ddc2ff029891592d0e03f5c..8d77ad312a011e1c08a7f9b468ea4ab32e110425 100644
--- a/cmd/gotk/create_helmrelease.go
+++ b/cmd/gotk/create_helmrelease.go
@@ -19,14 +19,13 @@ package main
 import (
 	"context"
 	"fmt"
-	"github.com/fluxcd/pkg/apis/meta"
 	"io/ioutil"
 
+	"github.com/fluxcd/pkg/apis/meta"
+
 	"github.com/spf13/cobra"
-	corev1 "k8s.io/api/core/v1"
 	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
-	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/wait"
@@ -34,7 +33,6 @@ import (
 	"sigs.k8s.io/yaml"
 
 	helmv2 "github.com/fluxcd/helm-controller/api/v2beta1"
-	sourcev1 "github.com/fluxcd/source-controller/api/v1beta1"
 )
 
 var createHelmReleaseCmd = &cobra.Command{
@@ -100,7 +98,7 @@ var (
 )
 
 func init() {
-	createHelmReleaseCmd.Flags().StringVar(&hrName, "release-name", "", "name used for the Helm release, defaults to a composition of '[<target-namespace>-]<hr-name>'")
+	createHelmReleaseCmd.Flags().StringVar(&hrName, "release-name", "", "name used for the Helm release, defaults to a composition of '[<target-namespace>-]<HelmRelease-name>'")
 	createHelmReleaseCmd.Flags().StringVar(&hrSource, "source", "", "source that contains the chart (<kind>/<name>)")
 	createHelmReleaseCmd.Flags().StringVar(&hrChart, "chart", "", "Helm chart name or path")
 	createHelmReleaseCmd.Flags().StringVar(&hrChartVersion, "chart-version", "", "Helm chart version, accepts a semver range (ignored for charts from GitRepository sources)")
@@ -112,7 +110,7 @@ func init() {
 
 func createHelmReleaseCmdRun(cmd *cobra.Command, args []string) error {
 	if len(args) < 1 {
-		return fmt.Errorf("release name is required")
+		return fmt.Errorf("HelmRelease name is required")
 	}
 	name := args[0]
 
@@ -137,7 +135,7 @@ func createHelmReleaseCmdRun(cmd *cobra.Command, args []string) error {
 	}
 
 	if !export {
-		logger.Generatef("generating release")
+		logger.Generatef("generating HelmRelease")
 	}
 
 	helmRelease := helmv2.HelmRelease{
@@ -193,43 +191,25 @@ func createHelmReleaseCmdRun(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	logger.Actionf("applying release")
-	if err := upsertHelmRelease(ctx, kubeClient, helmRelease); err != nil {
+	logger.Actionf("applying HelmRelease")
+	namespacedName, err := upsertHelmRelease(ctx, kubeClient, &helmRelease)
+	if err != nil {
 		return err
 	}
 
-	logger.Waitingf("waiting for reconciliation")
-	chartName := fmt.Sprintf("%s-%s", namespace, name)
-	if err := wait.PollImmediate(pollInterval, timeout,
-		isHelmChartReady(ctx, kubeClient, chartName, namespace)); err != nil {
-		return err
-	}
+	logger.Waitingf("waiting for HelmRelease reconciliation")
 	if err := wait.PollImmediate(pollInterval, timeout,
-		isHelmReleaseReady(ctx, kubeClient, name, namespace)); err != nil {
+		isHelmReleaseReady(ctx, kubeClient, namespacedName, &helmRelease)); err != nil {
 		return err
 	}
+	logger.Successf("HelmRelease %s is ready", name)
 
-	logger.Successf("release %s is ready", name)
-
-	namespacedName := types.NamespacedName{
-		Namespace: namespace,
-		Name:      name,
-	}
-	err = kubeClient.Get(ctx, namespacedName, &helmRelease)
-	if err != nil {
-		return fmt.Errorf("release failed: %w", err)
-	}
-
-	if helmRelease.Status.LastAppliedRevision != "" {
-		logger.Successf("applied revision %s", helmRelease.Status.LastAppliedRevision)
-	} else {
-		return fmt.Errorf("reconciliation failed")
-	}
-
+	logger.Successf("applied revision %s", helmRelease.Status.LastAppliedRevision)
 	return nil
 }
 
-func upsertHelmRelease(ctx context.Context, kubeClient client.Client, helmRelease helmv2.HelmRelease) error {
+func upsertHelmRelease(ctx context.Context, kubeClient client.Client,
+	helmRelease *helmv2.HelmRelease) (types.NamespacedName, error) {
 	namespacedName := types.NamespacedName{
 		Namespace: helmRelease.GetNamespace(),
 		Name:      helmRelease.GetName(),
@@ -239,75 +219,39 @@ func upsertHelmRelease(ctx context.Context, kubeClient client.Client, helmReleas
 	err := kubeClient.Get(ctx, namespacedName, &existing)
 	if err != nil {
 		if errors.IsNotFound(err) {
-			if err := kubeClient.Create(ctx, &helmRelease); err != nil {
-				return err
+			if err := kubeClient.Create(ctx, helmRelease); err != nil {
+				return namespacedName, err
 			} else {
-				logger.Successf("release created")
-				return nil
+				logger.Successf("HelmRelease created")
+				return namespacedName, nil
 			}
 		}
-		return err
+		return namespacedName, err
 	}
 
 	existing.Labels = helmRelease.Labels
 	existing.Spec = helmRelease.Spec
 	if err := kubeClient.Update(ctx, &existing); err != nil {
-		return err
+		return namespacedName, err
 	}
-
-	logger.Successf("release updated")
-	return nil
+	helmRelease = &existing
+	logger.Successf("HelmRelease updated")
+	return namespacedName, nil
 }
 
-func isHelmChartReady(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isHelmReleaseReady(ctx context.Context, kubeClient client.Client,
+	namespacedName types.NamespacedName, helmRelease *helmv2.HelmRelease) wait.ConditionFunc {
 	return func() (bool, error) {
-		var helmChart sourcev1.HelmChart
-		namespacedName := types.NamespacedName{
-			Namespace: namespace,
-			Name:      name,
-		}
-
-		err := kubeClient.Get(ctx, namespacedName, &helmChart)
+		err := kubeClient.Get(ctx, namespacedName, helmRelease)
 		if err != nil {
-			if apierrors.IsNotFound(err) {
-				return false, nil
-			}
 			return false, err
 		}
 
-		if c := meta.GetCondition(helmChart.Status.Conditions, meta.ReadyCondition); c != nil {
-			switch c.Status {
-			case corev1.ConditionTrue:
-				return true, nil
-			case corev1.ConditionFalse:
-				return false, fmt.Errorf(c.Message)
-			}
+		// Confirm the state we are observing is for the current generation
+		if helmRelease.Generation != helmRelease.Status.ObservedGeneration {
+			return false, nil
 		}
-		return false, nil
-	}
-}
 
-func isHelmReleaseReady(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
-	return func() (bool, error) {
-		var helmRelease helmv2.HelmRelease
-		namespacedName := types.NamespacedName{
-			Namespace: namespace,
-			Name:      name,
-		}
-
-		err := kubeClient.Get(ctx, namespacedName, &helmRelease)
-		if err != nil {
-			return false, err
-		}
-
-		if c := meta.GetCondition(helmRelease.Status.Conditions, meta.ReadyCondition); c != nil {
-			switch c.Status {
-			case corev1.ConditionTrue:
-				return true, nil
-			case corev1.ConditionFalse:
-				return false, fmt.Errorf(c.Message)
-			}
-		}
-		return false, nil
+		return meta.HasReadyCondition(helmRelease.Status.Conditions), nil
 	}
 }
diff --git a/cmd/gotk/create_kustomization.go b/cmd/gotk/create_kustomization.go
index e4df9b767f36ba8577c79d5b81eee24280f8e903..d3fdd0c6be30606094765cbedc82a1a98578aa96 100644
--- a/cmd/gotk/create_kustomization.go
+++ b/cmd/gotk/create_kustomization.go
@@ -102,7 +102,7 @@ func init() {
 
 func createKsCmdRun(cmd *cobra.Command, args []string) error {
 	if len(args) < 1 {
-		return fmt.Errorf("kustomization name is required")
+		return fmt.Errorf("Kustomization name is required")
 	}
 	name := args[0]
 
@@ -127,7 +127,7 @@ func createKsCmdRun(cmd *cobra.Command, args []string) error {
 	}
 
 	if !export {
-		logger.Generatef("generating kustomization")
+		logger.Generatef("generating Kustomization")
 	}
 
 	ksLabels, err := parseLabels()
@@ -232,38 +232,25 @@ func createKsCmdRun(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	logger.Actionf("applying kustomization")
-	if err := upsertKustomization(ctx, kubeClient, kustomization); err != nil {
+	logger.Actionf("applying Kustomization")
+	namespacedName, err := upsertKustomization(ctx, kubeClient, &kustomization)
+	if err != nil {
 		return err
 	}
 
-	logger.Waitingf("waiting for kustomization sync")
+	logger.Waitingf("waiting for Kustomization reconciliation")
 	if err := wait.PollImmediate(pollInterval, timeout,
-		isKustomizationReady(ctx, kubeClient, name, namespace)); err != nil {
+		isKustomizationReady(ctx, kubeClient, namespacedName, &kustomization)); err != nil {
 		return err
 	}
+	logger.Successf("Kustomization %s is ready", name)
 
-	logger.Successf("kustomization %s is ready", name)
-
-	namespacedName := types.NamespacedName{
-		Namespace: namespace,
-		Name:      name,
-	}
-	err = kubeClient.Get(ctx, namespacedName, &kustomization)
-	if err != nil {
-		return fmt.Errorf("kustomization sync failed: %w", err)
-	}
-
-	if kustomization.Status.LastAppliedRevision != "" {
-		logger.Successf("applied revision %s", kustomization.Status.LastAppliedRevision)
-	} else {
-		return fmt.Errorf("kustomization sync failed")
-	}
-
+	logger.Successf("applied revision %s", kustomization.Status.LastAppliedRevision)
 	return nil
 }
 
-func upsertKustomization(ctx context.Context, kubeClient client.Client, kustomization kustomizev1.Kustomization) error {
+func upsertKustomization(ctx context.Context, kubeClient client.Client,
+	kustomization *kustomizev1.Kustomization) (types.NamespacedName, error) {
 	namespacedName := types.NamespacedName{
 		Namespace: kustomization.GetNamespace(),
 		Name:      kustomization.GetName(),
@@ -273,39 +260,39 @@ func upsertKustomization(ctx context.Context, kubeClient client.Client, kustomiz
 	err := kubeClient.Get(ctx, namespacedName, &existing)
 	if err != nil {
 		if errors.IsNotFound(err) {
-			if err := kubeClient.Create(ctx, &kustomization); err != nil {
-				return err
+			if err := kubeClient.Create(ctx, kustomization); err != nil {
+				return namespacedName, err
 			} else {
-				logger.Successf("kustomization created")
-				return nil
+				logger.Successf("Kustomization created")
+				return namespacedName, nil
 			}
 		}
-		return err
+		return namespacedName, err
 	}
 
 	existing.Labels = kustomization.Labels
 	existing.Spec = kustomization.Spec
 	if err := kubeClient.Update(ctx, &existing); err != nil {
-		return err
+		return namespacedName, err
 	}
-
-	logger.Successf("kustomization updated")
-	return nil
+	kustomization = &existing
+	logger.Successf("Kustomization updated")
+	return namespacedName, nil
 }
 
-func isKustomizationReady(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isKustomizationReady(ctx context.Context, kubeClient client.Client,
+	namespacedName types.NamespacedName, kustomization *kustomizev1.Kustomization) wait.ConditionFunc {
 	return func() (bool, error) {
-		var kustomization kustomizev1.Kustomization
-		namespacedName := types.NamespacedName{
-			Namespace: namespace,
-			Name:      name,
-		}
-
-		err := kubeClient.Get(ctx, namespacedName, &kustomization)
+		err := kubeClient.Get(ctx, namespacedName, kustomization)
 		if err != nil {
 			return false, err
 		}
 
+		// Confirm the state we are observing is for the current generation
+		if kustomization.Generation != kustomization.Status.ObservedGeneration {
+			return false, nil
+		}
+
 		if c := meta.GetCondition(kustomization.Status.Conditions, meta.ReadyCondition); c != nil {
 			switch c.Status {
 			case corev1.ConditionTrue:
diff --git a/cmd/gotk/create_receiver.go b/cmd/gotk/create_receiver.go
index 367cd6a520108d4016aa3ea394b8f36b824c3422..08595bfe0206bf9f8b78f256e753f55cef152c2d 100644
--- a/cmd/gotk/create_receiver.go
+++ b/cmd/gotk/create_receiver.go
@@ -65,12 +65,12 @@ func init() {
 
 func createReceiverCmdRun(cmd *cobra.Command, args []string) error {
 	if len(args) < 1 {
-		return fmt.Errorf("receiver name is required")
+		return fmt.Errorf("Receiver name is required")
 	}
 	name := args[0]
 
 	if rcvType == "" {
-		return fmt.Errorf("type is required")
+		return fmt.Errorf("Receiver type is required")
 	}
 
 	if rcvSecretRef == "" {
@@ -100,7 +100,7 @@ func createReceiverCmdRun(cmd *cobra.Command, args []string) error {
 	}
 
 	if !export {
-		logger.Generatef("generating receiver")
+		logger.Generatef("generating Receiver")
 	}
 
 	receiver := notificationv1.Receiver{
@@ -132,34 +132,25 @@ func createReceiverCmdRun(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	logger.Actionf("applying receiver")
-	if err := upsertReceiver(ctx, kubeClient, receiver); err != nil {
+	logger.Actionf("applying Receiver")
+	namespacedName, err := upsertReceiver(ctx, kubeClient, &receiver)
+	if err != nil {
 		return err
 	}
 
-	logger.Waitingf("waiting for reconciliation")
+	logger.Waitingf("waiting for Receiver reconciliation")
 	if err := wait.PollImmediate(pollInterval, timeout,
-		isReceiverReady(ctx, kubeClient, name, namespace)); err != nil {
+		isReceiverReady(ctx, kubeClient, namespacedName, &receiver)); err != nil {
 		return err
 	}
-
-	logger.Successf("receiver %s is ready", name)
-
-	namespacedName := types.NamespacedName{
-		Namespace: namespace,
-		Name:      name,
-	}
-	err = kubeClient.Get(ctx, namespacedName, &receiver)
-	if err != nil {
-		return fmt.Errorf("receiver sync failed: %w", err)
-	}
+	logger.Successf("Receiver %s is ready", name)
 
 	logger.Successf("generated webhook URL %s", receiver.Status.URL)
-
 	return nil
 }
 
-func upsertReceiver(ctx context.Context, kubeClient client.Client, receiver notificationv1.Receiver) error {
+func upsertReceiver(ctx context.Context, kubeClient client.Client,
+	receiver *notificationv1.Receiver) (types.NamespacedName, error) {
 	namespacedName := types.NamespacedName{
 		Namespace: receiver.GetNamespace(),
 		Name:      receiver.GetName(),
@@ -169,35 +160,30 @@ func upsertReceiver(ctx context.Context, kubeClient client.Client, receiver noti
 	err := kubeClient.Get(ctx, namespacedName, &existing)
 	if err != nil {
 		if errors.IsNotFound(err) {
-			if err := kubeClient.Create(ctx, &receiver); err != nil {
-				return err
+			if err := kubeClient.Create(ctx, receiver); err != nil {
+				return namespacedName, err
 			} else {
-				logger.Successf("receiver created")
-				return nil
+				logger.Successf("Receiver created")
+				return namespacedName, nil
 			}
 		}
-		return err
+		return namespacedName, err
 	}
 
 	existing.Labels = receiver.Labels
 	existing.Spec = receiver.Spec
 	if err := kubeClient.Update(ctx, &existing); err != nil {
-		return err
+		return namespacedName, err
 	}
-
-	logger.Successf("receiver updated")
-	return nil
+	receiver = &existing
+	logger.Successf("Receiver updated")
+	return namespacedName, nil
 }
 
-func isReceiverReady(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isReceiverReady(ctx context.Context, kubeClient client.Client,
+	namespacedName types.NamespacedName, receiver *notificationv1.Receiver) wait.ConditionFunc {
 	return func() (bool, error) {
-		var receiver notificationv1.Receiver
-		namespacedName := types.NamespacedName{
-			Namespace: namespace,
-			Name:      name,
-		}
-
-		err := kubeClient.Get(ctx, namespacedName, &receiver)
+		err := kubeClient.Get(ctx, namespacedName, receiver)
 		if err != nil {
 			return false, err
 		}
diff --git a/cmd/gotk/create_source_bucket.go b/cmd/gotk/create_source_bucket.go
index 254bd5849cd5b7ad4db6cb91d8203300a040fc6d..32a06ea100902ee38bc7e4bd8cfec651724e45fd 100644
--- a/cmd/gotk/create_source_bucket.go
+++ b/cmd/gotk/create_source_bucket.go
@@ -83,13 +83,13 @@ func init() {
 
 func createSourceBucketCmdRun(cmd *cobra.Command, args []string) error {
 	if len(args) < 1 {
-		return fmt.Errorf("source name is required")
+		return fmt.Errorf("Bucket source name is required")
 	}
 	name := args[0]
 	secretName := fmt.Sprintf("bucket-%s", name)
 
 	if !utils.containsItemString(supportedSourceBucketProviders, sourceBucketProvider) {
-		return fmt.Errorf("bucket provider %s is not supported, can be %v",
+		return fmt.Errorf("Bucket provider %s is not supported, can be %v",
 			sourceBucketProvider, supportedSourceBucketProviders)
 	}
 
@@ -112,7 +112,7 @@ func createSourceBucketCmdRun(cmd *cobra.Command, args []string) error {
 	}
 	defer os.RemoveAll(tmpDir)
 
-	bucket := sourcev1.Bucket{
+	bucket := &sourcev1.Bucket{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      name,
 			Namespace: namespace,
@@ -131,7 +131,7 @@ func createSourceBucketCmdRun(cmd *cobra.Command, args []string) error {
 	}
 
 	if export {
-		return exportBucket(bucket)
+		return exportBucket(*bucket)
 	}
 
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
@@ -142,7 +142,7 @@ func createSourceBucketCmdRun(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	logger.Generatef("generating source")
+	logger.Generatef("generating Bucket source")
 
 	secret := corev1.Secret{
 		ObjectMeta: metav1.ObjectMeta{
@@ -168,38 +168,28 @@ func createSourceBucketCmdRun(cmd *cobra.Command, args []string) error {
 		logger.Successf("authentication configured")
 	}
 
-	logger.Actionf("applying source")
-	if err := upsertBucket(ctx, kubeClient, bucket); err != nil {
+	logger.Actionf("applying Bucket source")
+	namespacedName, err := upsertBucket(ctx, kubeClient, bucket)
+	if err != nil {
 		return err
 	}
 
-	logger.Waitingf("waiting for download")
+	logger.Waitingf("waiting for Bucket source reconciliation")
 	if err := wait.PollImmediate(pollInterval, timeout,
-		isBucketReady(ctx, kubeClient, name, namespace)); err != nil {
+		isBucketReady(ctx, kubeClient, namespacedName, bucket)); err != nil {
 		return err
 	}
+	logger.Successf("Bucket source reconciliation completed")
 
-	logger.Successf("download completed")
-
-	namespacedName := types.NamespacedName{
-		Namespace: namespace,
-		Name:      name,
-	}
-	err = kubeClient.Get(ctx, namespacedName, &bucket)
-	if err != nil {
-		return fmt.Errorf("could not retrieve bucket: %w", err)
-	}
-
-	if bucket.Status.Artifact != nil {
-		logger.Successf("fetched revision: %s", bucket.Status.Artifact.Revision)
-	} else {
-		return fmt.Errorf("download failed, artifact not found")
+	if bucket.Status.Artifact == nil {
+		return fmt.Errorf("Bucket source reconciliation but no artifact was found")
 	}
-
+	logger.Successf("fetched revision: %s", bucket.Status.Artifact.Revision)
 	return nil
 }
 
-func upsertBucket(ctx context.Context, kubeClient client.Client, bucket sourcev1.Bucket) error {
+func upsertBucket(ctx context.Context, kubeClient client.Client,
+	bucket *sourcev1.Bucket) (types.NamespacedName, error) {
 	namespacedName := types.NamespacedName{
 		Namespace: bucket.GetNamespace(),
 		Name:      bucket.GetName(),
@@ -209,22 +199,22 @@ func upsertBucket(ctx context.Context, kubeClient client.Client, bucket sourcev1
 	err := kubeClient.Get(ctx, namespacedName, &existing)
 	if err != nil {
 		if errors.IsNotFound(err) {
-			if err := kubeClient.Create(ctx, &bucket); err != nil {
-				return err
+			if err := kubeClient.Create(ctx, bucket); err != nil {
+				return namespacedName, err
 			} else {
-				logger.Successf("source created")
-				return nil
+				logger.Successf("Bucket source created")
+				return namespacedName, nil
 			}
 		}
-		return err
+		return namespacedName, err
 	}
 
 	existing.Labels = bucket.Labels
 	existing.Spec = bucket.Spec
 	if err := kubeClient.Update(ctx, &existing); err != nil {
-		return err
+		return namespacedName, err
 	}
-
-	logger.Successf("source updated")
-	return nil
+	bucket = &existing
+	logger.Successf("Bucket source updated")
+	return namespacedName, nil
 }
diff --git a/cmd/gotk/create_source_git.go b/cmd/gotk/create_source_git.go
index 86831ec90fded788a0460cdce859325ffbdd40b3..ad78484134345632e14832a7c979814c25df55eb 100644
--- a/cmd/gotk/create_source_git.go
+++ b/cmd/gotk/create_source_git.go
@@ -111,7 +111,7 @@ func init() {
 
 func createSourceGitCmdRun(cmd *cobra.Command, args []string) error {
 	if len(args) < 1 {
-		return fmt.Errorf("source name is required")
+		return fmt.Errorf("GitRepository source name is required")
 	}
 	name := args[0]
 
@@ -234,7 +234,7 @@ func createSourceGitCmdRun(cmd *cobra.Command, args []string) error {
 		logger.Successf("authentication configured")
 	}
 
-	logger.Generatef("generating source")
+	logger.Generatef("generating GitRepository source")
 
 	if withAuth {
 		gitRepository.Spec.SecretRef = &corev1.LocalObjectReference{
@@ -242,34 +242,23 @@ func createSourceGitCmdRun(cmd *cobra.Command, args []string) error {
 		}
 	}
 
-	logger.Actionf("applying source")
-	if err := upsertGitRepository(ctx, kubeClient, gitRepository); err != nil {
+	logger.Actionf("applying GitRepository source")
+	namespacedName, err := upsertGitRepository(ctx, kubeClient, &gitRepository)
+	if err != nil {
 		return err
 	}
 
-	logger.Waitingf("waiting for git sync")
+	logger.Waitingf("waiting for GitRepository source reconciliation")
 	if err := wait.PollImmediate(pollInterval, timeout,
-		isGitRepositoryReady(ctx, kubeClient, name, namespace)); err != nil {
+		isGitRepositoryReady(ctx, kubeClient, namespacedName, &gitRepository)); err != nil {
 		return err
 	}
+	logger.Successf("GitRepository source reconciliation completed")
 
-	logger.Successf("git sync completed")
-
-	namespacedName := types.NamespacedName{
-		Namespace: namespace,
-		Name:      name,
-	}
-	err = kubeClient.Get(ctx, namespacedName, &gitRepository)
-	if err != nil {
-		return fmt.Errorf("git sync failed: %w", err)
-	}
-
-	if gitRepository.Status.Artifact != nil {
-		logger.Successf("fetched revision: %s", gitRepository.Status.Artifact.Revision)
-	} else {
-		return fmt.Errorf("git sync failed, artifact not found")
+	if gitRepository.Status.Artifact == nil {
+		return fmt.Errorf("GitRepository source reconciliation completed but no artifact was found")
 	}
-
+	logger.Successf("fetched revision: %s", gitRepository.Status.Artifact.Revision)
 	return nil
 }
 
@@ -330,7 +319,8 @@ func upsertSecret(ctx context.Context, kubeClient client.Client, secret corev1.S
 	return nil
 }
 
-func upsertGitRepository(ctx context.Context, kubeClient client.Client, gitRepository sourcev1.GitRepository) error {
+func upsertGitRepository(ctx context.Context, kubeClient client.Client,
+	gitRepository *sourcev1.GitRepository) (types.NamespacedName, error) {
 	namespacedName := types.NamespacedName{
 		Namespace: gitRepository.GetNamespace(),
 		Name:      gitRepository.GetName(),
@@ -340,35 +330,30 @@ func upsertGitRepository(ctx context.Context, kubeClient client.Client, gitRepos
 	err := kubeClient.Get(ctx, namespacedName, &existing)
 	if err != nil {
 		if errors.IsNotFound(err) {
-			if err := kubeClient.Create(ctx, &gitRepository); err != nil {
-				return err
+			if err := kubeClient.Create(ctx, gitRepository); err != nil {
+				return namespacedName, err
 			} else {
-				logger.Successf("source created")
-				return nil
+				logger.Successf("GitRepository source created")
+				return namespacedName, nil
 			}
 		}
-		return err
+		return namespacedName, err
 	}
 
 	existing.Labels = gitRepository.Labels
 	existing.Spec = gitRepository.Spec
 	if err := kubeClient.Update(ctx, &existing); err != nil {
-		return err
+		return namespacedName, err
 	}
-
-	logger.Successf("source updated")
-	return nil
+	gitRepository = &existing
+	logger.Successf("GitRepository source updated")
+	return namespacedName, nil
 }
 
-func isGitRepositoryReady(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isGitRepositoryReady(ctx context.Context, kubeClient client.Client,
+	namespacedName types.NamespacedName, gitRepository *sourcev1.GitRepository) wait.ConditionFunc {
 	return func() (bool, error) {
-		var gitRepository sourcev1.GitRepository
-		namespacedName := types.NamespacedName{
-			Namespace: namespace,
-			Name:      name,
-		}
-
-		err := kubeClient.Get(ctx, namespacedName, &gitRepository)
+		err := kubeClient.Get(ctx, namespacedName, gitRepository)
 		if err != nil {
 			return false, err
 		}
diff --git a/cmd/gotk/create_source_helm.go b/cmd/gotk/create_source_helm.go
index 4ebf81bf371fa872544db7d5ed25b97ff46d9db2..bc6c9a081f28cd1fa3f8d4b6d5c71cf7d070512e 100644
--- a/cmd/gotk/create_source_helm.go
+++ b/cmd/gotk/create_source_helm.go
@@ -83,7 +83,7 @@ func init() {
 
 func createSourceHelmCmdRun(cmd *cobra.Command, args []string) error {
 	if len(args) < 1 {
-		return fmt.Errorf("source name is required")
+		return fmt.Errorf("HelmRepository source name is required")
 	}
 	name := args[0]
 	secretName := fmt.Sprintf("helm-%s", name)
@@ -107,7 +107,7 @@ func createSourceHelmCmdRun(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("url parse failed: %w", err)
 	}
 
-	helmRepository := sourcev1.HelmRepository{
+	helmRepository := &sourcev1.HelmRepository{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      name,
 			Namespace: namespace,
@@ -122,7 +122,7 @@ func createSourceHelmCmdRun(cmd *cobra.Command, args []string) error {
 	}
 
 	if export {
-		return exportHelmRepository(helmRepository)
+		return exportHelmRepository(*helmRepository)
 	}
 
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
@@ -133,7 +133,7 @@ func createSourceHelmCmdRun(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	logger.Generatef("generating source")
+	logger.Generatef("generating HelmRepository source")
 
 	secret := corev1.Secret{
 		ObjectMeta: metav1.ObjectMeta{
@@ -181,38 +181,28 @@ func createSourceHelmCmdRun(cmd *cobra.Command, args []string) error {
 		logger.Successf("authentication configured")
 	}
 
-	logger.Actionf("applying source")
-	if err := upsertHelmRepository(ctx, kubeClient, helmRepository); err != nil {
+	logger.Actionf("applying HelmRepository source")
+	namespacedName, err := upsertHelmRepository(ctx, kubeClient, helmRepository)
+	if err != nil {
 		return err
 	}
 
-	logger.Waitingf("waiting for index download")
+	logger.Waitingf("waiting for HelmRepository source reconciliation")
 	if err := wait.PollImmediate(pollInterval, timeout,
-		isHelmRepositoryReady(ctx, kubeClient, name, namespace)); err != nil {
+		isHelmRepositoryReady(ctx, kubeClient, namespacedName, helmRepository)); err != nil {
 		return err
 	}
+	logger.Successf("HelmRepository source reconciliation completed")
 
-	logger.Successf("index download completed")
-
-	namespacedName := types.NamespacedName{
-		Namespace: namespace,
-		Name:      name,
-	}
-	err = kubeClient.Get(ctx, namespacedName, &helmRepository)
-	if err != nil {
-		return fmt.Errorf("helm index failed: %w", err)
-	}
-
-	if helmRepository.Status.Artifact != nil {
-		logger.Successf("fetched revision: %s", helmRepository.Status.Artifact.Revision)
-	} else {
-		return fmt.Errorf("index download failed, artifact not found")
+	if helmRepository.Status.Artifact == nil {
+		return fmt.Errorf("HelmRepository source reconciliation completed but no artifact was found")
 	}
-
+	logger.Successf("fetched revision: %s", helmRepository.Status.Artifact.Revision)
 	return nil
 }
 
-func upsertHelmRepository(ctx context.Context, kubeClient client.Client, helmRepository sourcev1.HelmRepository) error {
+func upsertHelmRepository(ctx context.Context, kubeClient client.Client,
+	helmRepository *sourcev1.HelmRepository) (types.NamespacedName, error) {
 	namespacedName := types.NamespacedName{
 		Namespace: helmRepository.GetNamespace(),
 		Name:      helmRepository.GetName(),
@@ -222,22 +212,22 @@ func upsertHelmRepository(ctx context.Context, kubeClient client.Client, helmRep
 	err := kubeClient.Get(ctx, namespacedName, &existing)
 	if err != nil {
 		if errors.IsNotFound(err) {
-			if err := kubeClient.Create(ctx, &helmRepository); err != nil {
-				return err
+			if err := kubeClient.Create(ctx, helmRepository); err != nil {
+				return namespacedName, err
 			} else {
 				logger.Successf("source created")
-				return nil
+				return namespacedName, nil
 			}
 		}
-		return err
+		return namespacedName, err
 	}
 
 	existing.Labels = helmRepository.Labels
 	existing.Spec = helmRepository.Spec
 	if err := kubeClient.Update(ctx, &existing); err != nil {
-		return err
+		return namespacedName, err
 	}
-
+	helmRepository = &existing
 	logger.Successf("source updated")
-	return nil
+	return namespacedName, nil
 }
diff --git a/cmd/gotk/reconcile_alert.go b/cmd/gotk/reconcile_alert.go
index 6d29afda623781dd1661d92a798b35c0198b6396..fc6e56db0eab2f00854946b1b582fc4dfbd568d4 100644
--- a/cmd/gotk/reconcile_alert.go
+++ b/cmd/gotk/reconcile_alert.go
@@ -45,7 +45,7 @@ func init() {
 
 func reconcileAlertCmdRun(cmd *cobra.Command, args []string) error {
 	if len(args) < 1 {
-		return fmt.Errorf("alert name is required")
+		return fmt.Errorf("Alert name is required")
 	}
 	name := args[0]
 
@@ -62,7 +62,7 @@ func reconcileAlertCmdRun(cmd *cobra.Command, args []string) error {
 		Name:      name,
 	}
 
-	logger.Actionf("annotating alert %s in %s namespace", name, namespace)
+	logger.Actionf("annotating Alert %s in %s namespace", name, namespace)
 	var alert notificationv1.Alert
 	err = kubeClient.Get(ctx, namespacedName, &alert)
 	if err != nil {
@@ -79,15 +79,13 @@ func reconcileAlertCmdRun(cmd *cobra.Command, args []string) error {
 	if err := kubeClient.Update(ctx, &alert); err != nil {
 		return err
 	}
-	logger.Successf("alert annotated")
+	logger.Successf("Alert annotated")
 
 	logger.Waitingf("waiting for reconciliation")
 	if err := wait.PollImmediate(pollInterval, timeout,
-		isAlertReady(ctx, kubeClient, name, namespace)); err != nil {
+		isAlertReady(ctx, kubeClient, namespacedName, &alert)); err != nil {
 		return err
 	}
-
-	logger.Successf("alert reconciliation completed")
-
+	logger.Successf("Alert reconciliation completed")
 	return nil
 }
diff --git a/cmd/gotk/reconcile_alertprovider.go b/cmd/gotk/reconcile_alertprovider.go
index 15194f79f28b5f2c117b4f1d65aed77cdbc5365d..c8f4e9efed935d7d327af0d22369827d93e5c700 100644
--- a/cmd/gotk/reconcile_alertprovider.go
+++ b/cmd/gotk/reconcile_alertprovider.go
@@ -45,7 +45,7 @@ func init() {
 
 func reconcileAlertProviderCmdRun(cmd *cobra.Command, args []string) error {
 	if len(args) < 1 {
-		return fmt.Errorf("provider name is required")
+		return fmt.Errorf("Provider name is required")
 	}
 	name := args[0]
 
@@ -62,7 +62,7 @@ func reconcileAlertProviderCmdRun(cmd *cobra.Command, args []string) error {
 		Name:      name,
 	}
 
-	logger.Actionf("annotating provider %s in %s namespace", name, namespace)
+	logger.Actionf("annotating Provider %s in %s namespace", name, namespace)
 	var alertProvider notificationv1.Provider
 	err = kubeClient.Get(ctx, namespacedName, &alertProvider)
 	if err != nil {
@@ -79,15 +79,13 @@ func reconcileAlertProviderCmdRun(cmd *cobra.Command, args []string) error {
 	if err := kubeClient.Update(ctx, &alertProvider); err != nil {
 		return err
 	}
-	logger.Successf("provider annotated")
+	logger.Successf("Provider annotated")
 
 	logger.Waitingf("waiting for reconciliation")
 	if err := wait.PollImmediate(pollInterval, timeout,
-		isAlertProviderReady(ctx, kubeClient, name, namespace)); err != nil {
+		isAlertProviderReady(ctx, kubeClient, namespacedName, &alertProvider)); err != nil {
 		return err
 	}
-
-	logger.Successf("provider reconciliation completed")
-
+	logger.Successf("Provider reconciliation completed")
 	return nil
 }
diff --git a/cmd/gotk/reconcile_helmrelease.go b/cmd/gotk/reconcile_helmrelease.go
index 398bb40dcffff5e072951cde4655dc677a15653a..af4273ce0ec1e5559c1e67acd31e8508965c799c 100644
--- a/cmd/gotk/reconcile_helmrelease.go
+++ b/cmd/gotk/reconcile_helmrelease.go
@@ -98,19 +98,19 @@ func reconcileHrCmdRun(cmd *cobra.Command, args []string) error {
 		}
 	}
 
+	lastHandledReconcileAt := helmRelease.Status.LastHandledReconcileAt
 	logger.Actionf("annotating HelmRelease %s in %s namespace", name, namespace)
-	if err := requestHelmReleaseReconciliation(ctx, kubeClient, namespacedName); err != nil {
+	if err := requestHelmReleaseReconciliation(ctx, kubeClient, namespacedName, &helmRelease); err != nil {
 		return err
 	}
 	logger.Successf("HelmRelease annotated")
 
 	logger.Waitingf("waiting for HelmRelease reconciliation")
 	if err := wait.PollImmediate(pollInterval, timeout,
-		helmReleaseReconciliationHandled(ctx, kubeClient, name, namespace, helmRelease.Status.LastHandledReconcileAt),
+		helmReleaseReconciliationHandled(ctx, kubeClient, namespacedName, &helmRelease, lastHandledReconcileAt),
 	); err != nil {
 		return err
 	}
-
 	logger.Successf("HelmRelease reconciliation completed")
 
 	err = kubeClient.Get(ctx, namespacedName, &helmRelease)
@@ -120,7 +120,7 @@ func reconcileHrCmdRun(cmd *cobra.Command, args []string) error {
 	if c := meta.GetCondition(helmRelease.Status.Conditions, meta.ReadyCondition); c != nil {
 		switch c.Status {
 		case corev1.ConditionFalse:
-			return fmt.Errorf("HelmRelease reconciliation failed")
+			return fmt.Errorf("HelmRelease reconciliation failed: %s", c.Message)
 		default:
 			logger.Successf("reconciled revision %s", helmRelease.Status.LastAppliedRevision)
 		}
@@ -129,39 +129,29 @@ func reconcileHrCmdRun(cmd *cobra.Command, args []string) error {
 }
 
 func helmReleaseReconciliationHandled(ctx context.Context, kubeClient client.Client,
-	name, namespace, lastHandledReconcileAt string) wait.ConditionFunc {
+	namespacedName types.NamespacedName, helmRelease *helmv2.HelmRelease, lastHandledReconcileAt string) wait.ConditionFunc {
 	return func() (bool, error) {
-		var helmRelease helmv2.HelmRelease
-		namespacedName := types.NamespacedName{
-			Namespace: namespace,
-			Name:      name,
-		}
-
-		err := kubeClient.Get(ctx, namespacedName, &helmRelease)
+		err := kubeClient.Get(ctx, namespacedName, helmRelease)
 		if err != nil {
 			return false, err
 		}
-
 		return helmRelease.Status.LastHandledReconcileAt != lastHandledReconcileAt, nil
 	}
 }
 
-func requestHelmReleaseReconciliation(ctx context.Context, kubeClient client.Client, namespacedName types.NamespacedName) error {
-	var release helmv2.HelmRelease
+func requestHelmReleaseReconciliation(ctx context.Context, kubeClient client.Client,
+	namespacedName types.NamespacedName, helmRelease *helmv2.HelmRelease) error {
 	return retry.RetryOnConflict(retry.DefaultBackoff, func() (err error) {
-		if err := kubeClient.Get(ctx, namespacedName, &release); err != nil {
+		if err := kubeClient.Get(ctx, namespacedName, helmRelease); err != nil {
 			return err
 		}
-
-		if release.Annotations == nil {
-			release.Annotations = map[string]string{
+		if helmRelease.Annotations == nil {
+			helmRelease.Annotations = map[string]string{
 				meta.ReconcileAtAnnotation: time.Now().Format(time.RFC3339Nano),
 			}
 		} else {
-			release.Annotations[meta.ReconcileAtAnnotation] = time.Now().Format(time.RFC3339Nano)
+			helmRelease.Annotations[meta.ReconcileAtAnnotation] = time.Now().Format(time.RFC3339Nano)
 		}
-
-		err = kubeClient.Update(ctx, &release)
-		return
+		return kubeClient.Update(ctx, helmRelease)
 	})
 }
diff --git a/cmd/gotk/reconcile_kustomization.go b/cmd/gotk/reconcile_kustomization.go
index b31bc7062df3589b82c1d2ca4d5d2d1831cc006f..ff4e5586703e52fed33b190f84891a65b1b8a9d2 100644
--- a/cmd/gotk/reconcile_kustomization.go
+++ b/cmd/gotk/reconcile_kustomization.go
@@ -54,14 +54,14 @@ var (
 )
 
 func init() {
-	reconcileKsCmd.Flags().BoolVar(&syncKsWithSource, "with-source", false, "reconcile kustomization source")
+	reconcileKsCmd.Flags().BoolVar(&syncKsWithSource, "with-source", false, "reconcile Kustomization source")
 
 	reconcileCmd.AddCommand(reconcileKsCmd)
 }
 
 func reconcileKsCmdRun(cmd *cobra.Command, args []string) error {
 	if len(args) < 1 {
-		return fmt.Errorf("kustomization name is required")
+		return fmt.Errorf("Kustomization name is required")
 	}
 	name := args[0]
 
@@ -77,7 +77,6 @@ func reconcileKsCmdRun(cmd *cobra.Command, args []string) error {
 		Namespace: namespace,
 		Name:      name,
 	}
-
 	var kustomization kustomizev1.Kustomization
 	err = kubeClient.Get(ctx, namespacedName, &kustomization)
 	if err != nil {
@@ -96,30 +95,26 @@ func reconcileKsCmdRun(cmd *cobra.Command, args []string) error {
 		}
 	}
 
-	logger.Actionf("annotating kustomization %s in %s namespace", name, namespace)
-	if err := requestKustomizeReconciliation(ctx, kubeClient, namespacedName); err != nil {
+	lastHandledReconcileAt := kustomization.Status.LastHandledReconcileAt
+	logger.Actionf("annotating Kustomization %s in %s namespace", name, namespace)
+	if err := requestKustomizeReconciliation(ctx, kubeClient, namespacedName, &kustomization); err != nil {
 		return err
 	}
-	logger.Successf("kustomization annotated")
+	logger.Successf("Kustomization annotated")
 
-	logger.Waitingf("waiting for kustomization reconciliation")
+	logger.Waitingf("waiting for Kustomization reconciliation")
 	if err := wait.PollImmediate(
 		pollInterval, timeout,
-		kustomizeReconciliationHandled(ctx, kubeClient, name, namespace, kustomization.Status.LastHandledReconcileAt),
+		kustomizeReconciliationHandled(ctx, kubeClient, namespacedName, &kustomization, lastHandledReconcileAt),
 	); err != nil {
 		return err
 	}
+	logger.Successf("Kustomization reconciliation completed")
 
-	logger.Successf("kustomization reconciliation completed")
-
-	err = kubeClient.Get(ctx, namespacedName, &kustomization)
-	if err != nil {
-		return err
-	}
 	if c := meta.GetCondition(kustomization.Status.Conditions, meta.ReadyCondition); c != nil {
 		switch c.Status {
 		case corev1.ConditionFalse:
-			return fmt.Errorf("kustomization reconciliation failed")
+			return fmt.Errorf("Kustomization reconciliation failed")
 		default:
 			logger.Successf("reconciled revision %s", kustomization.Status.LastAppliedRevision)
 		}
@@ -128,30 +123,22 @@ func reconcileKsCmdRun(cmd *cobra.Command, args []string) error {
 }
 
 func kustomizeReconciliationHandled(ctx context.Context, kubeClient client.Client,
-	name, namespace, lastHandledReconcileAt string) wait.ConditionFunc {
+	namespacedName types.NamespacedName, kustomization *kustomizev1.Kustomization, lastHandledReconcileAt string) wait.ConditionFunc {
 	return func() (bool, error) {
-		var kustomize kustomizev1.Kustomization
-		namespacedName := types.NamespacedName{
-			Namespace: namespace,
-			Name:      name,
-		}
-
-		err := kubeClient.Get(ctx, namespacedName, &kustomize)
+		err := kubeClient.Get(ctx, namespacedName, kustomization)
 		if err != nil {
 			return false, err
 		}
-
-		return kustomize.Status.LastHandledReconcileAt != lastHandledReconcileAt, nil
+		return kustomization.Status.LastHandledReconcileAt != lastHandledReconcileAt, nil
 	}
 }
 
-func requestKustomizeReconciliation(ctx context.Context, kubeClient client.Client, namespacedName types.NamespacedName) error {
-	var kustomization kustomizev1.Kustomization
+func requestKustomizeReconciliation(ctx context.Context, kubeClient client.Client,
+	namespacedName types.NamespacedName, kustomization *kustomizev1.Kustomization) error {
 	return retry.RetryOnConflict(retry.DefaultBackoff, func() (err error) {
-		if err := kubeClient.Get(ctx, namespacedName, &kustomization); err != nil {
+		if err := kubeClient.Get(ctx, namespacedName, kustomization); err != nil {
 			return err
 		}
-
 		if kustomization.Annotations == nil {
 			kustomization.Annotations = map[string]string{
 				meta.ReconcileAtAnnotation: time.Now().Format(time.RFC3339Nano),
@@ -159,8 +146,6 @@ func requestKustomizeReconciliation(ctx context.Context, kubeClient client.Clien
 		} else {
 			kustomization.Annotations[meta.ReconcileAtAnnotation] = time.Now().Format(time.RFC3339Nano)
 		}
-
-		err = kubeClient.Update(ctx, &kustomization)
-		return
+		return kubeClient.Update(ctx, kustomization)
 	})
 }
diff --git a/cmd/gotk/reconcile_receiver.go b/cmd/gotk/reconcile_receiver.go
index 7a7f6a863e8d2c841952e9636074eec1eb5b0b16..9b151ab7d5ba4705faee688f6a151036cd52d29d 100644
--- a/cmd/gotk/reconcile_receiver.go
+++ b/cmd/gotk/reconcile_receiver.go
@@ -62,7 +62,7 @@ func reconcileReceiverCmdRun(cmd *cobra.Command, args []string) error {
 		Name:      name,
 	}
 
-	logger.Actionf("annotating receiver %s in %s namespace", name, namespace)
+	logger.Actionf("annotating Receiver %s in %s namespace", name, namespace)
 	var receiver notificationv1.Receiver
 	err = kubeClient.Get(ctx, namespacedName, &receiver)
 	if err != nil {
@@ -79,15 +79,15 @@ func reconcileReceiverCmdRun(cmd *cobra.Command, args []string) error {
 	if err := kubeClient.Update(ctx, &receiver); err != nil {
 		return err
 	}
-	logger.Successf("receiver annotated")
+	logger.Successf("Receiver annotated")
 
-	logger.Waitingf("waiting for reconciliation")
+	logger.Waitingf("waiting for Receiver reconciliation")
 	if err := wait.PollImmediate(pollInterval, timeout,
-		isReceiverReady(ctx, kubeClient, name, namespace)); err != nil {
+		isReceiverReady(ctx, kubeClient, namespacedName, &receiver)); err != nil {
 		return err
 	}
 
-	logger.Successf("receiver reconciliation completed")
+	logger.Successf("Receiver reconciliation completed")
 
 	return nil
 }
diff --git a/cmd/gotk/reconcile_source_bucket.go b/cmd/gotk/reconcile_source_bucket.go
index 5ac0c1568924a11bcd4d4ed453345b47f9f08ba0..c823806f5d3b33a9fa6e043011511c391b9a8202 100644
--- a/cmd/gotk/reconcile_source_bucket.go
+++ b/cmd/gotk/reconcile_source_bucket.go
@@ -64,7 +64,7 @@ func reconcileSourceBucketCmdRun(cmd *cobra.Command, args []string) error {
 		Name:      name,
 	}
 
-	logger.Actionf("annotating source %s in %s namespace", name, namespace)
+	logger.Actionf("annotating Bucket source %s in %s namespace", name, namespace)
 	var bucket sourcev1.Bucket
 	err = kubeClient.Get(ctx, namespacedName, &bucket)
 	if err != nil {
@@ -81,42 +81,35 @@ func reconcileSourceBucketCmdRun(cmd *cobra.Command, args []string) error {
 	if err := kubeClient.Update(ctx, &bucket); err != nil {
 		return err
 	}
-	logger.Successf("source annotated")
+	logger.Successf("Bucket source annotated")
 
-	logger.Waitingf("waiting for reconciliation")
+	logger.Waitingf("waiting for Bucket source reconciliation")
 	if err := wait.PollImmediate(pollInterval, timeout,
-		isBucketReady(ctx, kubeClient, name, namespace)); err != nil {
+		isBucketReady(ctx, kubeClient, namespacedName, &bucket)); err != nil {
 		return err
 	}
+	logger.Successf("Bucket source reconciliation completed")
 
-	logger.Successf("bucket reconciliation completed")
-
-	err = kubeClient.Get(ctx, namespacedName, &bucket)
-	if err != nil {
-		return err
-	}
-
-	if bucket.Status.Artifact != nil {
-		logger.Successf("fetched revision %s", bucket.Status.Artifact.Revision)
-	} else {
-		return fmt.Errorf("bucket reconciliation failed, artifact not found")
+	if bucket.Status.Artifact == nil {
+		return fmt.Errorf("Bucket source reconciliation completed but no artifact was found")
 	}
+	logger.Successf("fetched revision %s", bucket.Status.Artifact.Revision)
 	return nil
 }
 
-func isBucketReady(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isBucketReady(ctx context.Context, kubeClient client.Client,
+	namespacedName types.NamespacedName, bucket *sourcev1.Bucket) wait.ConditionFunc {
 	return func() (bool, error) {
-		var bucket sourcev1.Bucket
-		namespacedName := types.NamespacedName{
-			Namespace: namespace,
-			Name:      name,
-		}
-
-		err := kubeClient.Get(ctx, namespacedName, &bucket)
+		err := kubeClient.Get(ctx, namespacedName, bucket)
 		if err != nil {
 			return false, err
 		}
 
+		// Confirm the state we are observing is for the current generation
+		if bucket.Generation != bucket.Status.ObservedGeneration {
+			return false, nil
+		}
+
 		if c := meta.GetCondition(bucket.Status.Conditions, meta.ReadyCondition); c != nil {
 			switch c.Status {
 			case corev1.ConditionTrue:
diff --git a/cmd/gotk/reconcile_source_git.go b/cmd/gotk/reconcile_source_git.go
index 5a79f2bd86b3e5e5792a2639c5bdedaffb9fe198..b586861ffb3fde0fb700f805982c48cba3a0baea 100644
--- a/cmd/gotk/reconcile_source_git.go
+++ b/cmd/gotk/reconcile_source_git.go
@@ -62,7 +62,7 @@ func reconcileSourceGitCmdRun(cmd *cobra.Command, args []string) error {
 		Name:      name,
 	}
 
-	logger.Actionf("annotating source %s in %s namespace", name, namespace)
+	logger.Actionf("annotating GitRepository source %s in %s namespace", name, namespace)
 	var gitRepository sourcev1.GitRepository
 	err = kubeClient.Get(ctx, namespacedName, &gitRepository)
 	if err != nil {
@@ -79,25 +79,18 @@ func reconcileSourceGitCmdRun(cmd *cobra.Command, args []string) error {
 	if err := kubeClient.Update(ctx, &gitRepository); err != nil {
 		return err
 	}
-	logger.Successf("source annotated")
+	logger.Successf("GitRepository source annotated")
 
-	logger.Waitingf("waiting for reconciliation")
+	logger.Waitingf("waiting for GitRepository source reconciliation")
 	if err := wait.PollImmediate(pollInterval, timeout,
-		isGitRepositoryReady(ctx, kubeClient, name, namespace)); err != nil {
+		isGitRepositoryReady(ctx, kubeClient, namespacedName, &gitRepository)); err != nil {
 		return err
 	}
+	logger.Successf("GitRepository source reconciliation completed")
 
-	logger.Successf("git reconciliation completed")
-
-	err = kubeClient.Get(ctx, namespacedName, &gitRepository)
-	if err != nil {
-		return err
-	}
-
-	if gitRepository.Status.Artifact != nil {
-		logger.Successf("fetched revision %s", gitRepository.Status.Artifact.Revision)
-	} else {
-		return fmt.Errorf("git reconciliation failed, artifact not found")
+	if gitRepository.Status.Artifact == nil {
+		return fmt.Errorf("GitRepository source reconciliation completed but no artifact was found")
 	}
+	logger.Successf("fetched revision %s", gitRepository.Status.Artifact.Revision)
 	return nil
 }
diff --git a/cmd/gotk/reconcile_source_helm.go b/cmd/gotk/reconcile_source_helm.go
index ea1ad3b8995aa3b7d4647c05a510774fa3d6c1af..3f1fe13a631963cf8bb1130817ea55276b8c94a5 100644
--- a/cmd/gotk/reconcile_source_helm.go
+++ b/cmd/gotk/reconcile_source_helm.go
@@ -47,7 +47,7 @@ func init() {
 
 func reconcileSourceHelmCmdRun(cmd *cobra.Command, args []string) error {
 	if len(args) < 1 {
-		return fmt.Errorf("source name is required")
+		return fmt.Errorf("HelmRepository source name is required")
 	}
 	name := args[0]
 
@@ -64,7 +64,7 @@ func reconcileSourceHelmCmdRun(cmd *cobra.Command, args []string) error {
 		Name:      name,
 	}
 
-	logger.Actionf("annotating source %s in %s namespace", name, namespace)
+	logger.Actionf("annotating HelmRepository source %s in %s namespace", name, namespace)
 	var helmRepository sourcev1.HelmRepository
 	err = kubeClient.Get(ctx, namespacedName, &helmRepository)
 	if err != nil {
@@ -81,42 +81,35 @@ func reconcileSourceHelmCmdRun(cmd *cobra.Command, args []string) error {
 	if err := kubeClient.Update(ctx, &helmRepository); err != nil {
 		return err
 	}
-	logger.Successf("source annotated")
+	logger.Successf("HelmRepository source annotated")
 
-	logger.Waitingf("waiting for reconciliation")
+	logger.Waitingf("waiting for HelmRepository source reconciliation")
 	if err := wait.PollImmediate(pollInterval, timeout,
-		isHelmRepositoryReady(ctx, kubeClient, name, namespace)); err != nil {
+		isHelmRepositoryReady(ctx, kubeClient, namespacedName, &helmRepository)); err != nil {
 		return err
 	}
+	logger.Successf("HelmRepository source reconciliation completed")
 
-	logger.Successf("helm reconciliation completed")
-
-	err = kubeClient.Get(ctx, namespacedName, &helmRepository)
-	if err != nil {
-		return err
-	}
-
-	if helmRepository.Status.Artifact != nil {
-		logger.Successf("fetched revision %s", helmRepository.Status.Artifact.Revision)
-	} else {
-		return fmt.Errorf("helm reconciliation failed, artifact not found")
+	if helmRepository.Status.Artifact == nil {
+		return fmt.Errorf("HelmRepository source reconciliation completed but no artifact was found")
 	}
+	logger.Successf("fetched revision %s", helmRepository.Status.Artifact.Revision)
 	return nil
 }
 
-func isHelmRepositoryReady(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isHelmRepositoryReady(ctx context.Context, kubeClient client.Client,
+	namespacedName types.NamespacedName, helmRepository *sourcev1.HelmRepository) wait.ConditionFunc {
 	return func() (bool, error) {
-		var helmRepository sourcev1.HelmRepository
-		namespacedName := types.NamespacedName{
-			Namespace: namespace,
-			Name:      name,
-		}
-
-		err := kubeClient.Get(ctx, namespacedName, &helmRepository)
+		err := kubeClient.Get(ctx, namespacedName, helmRepository)
 		if err != nil {
 			return false, err
 		}
 
+		// Confirm the state we are observing is for the current generation
+		if helmRepository.Generation != helmRepository.Status.ObservedGeneration {
+			return false, nil
+		}
+
 		if c := meta.GetCondition(helmRepository.Status.Conditions, meta.ReadyCondition); c != nil {
 			switch c.Status {
 			case corev1.ConditionTrue:
diff --git a/cmd/gotk/resume_alert.go b/cmd/gotk/resume_alert.go
index 30190cb340ebfa7b6a59ddd4afcbef8a618a1b3a..7624a45c76c12f3c34d2c911aae9932a19d5f83b 100644
--- a/cmd/gotk/resume_alert.go
+++ b/cmd/gotk/resume_alert.go
@@ -78,24 +78,17 @@ func resumeAlertCmdRun(cmd *cobra.Command, args []string) error {
 
 	logger.Waitingf("waiting for Alert reconciliation")
 	if err := wait.PollImmediate(pollInterval, timeout,
-		isAlertResumed(ctx, kubeClient, name, namespace)); err != nil {
+		isAlertResumed(ctx, kubeClient, namespacedName, &alert)); err != nil {
 		return err
 	}
-
 	logger.Successf("Alert reconciliation completed")
-
 	return nil
 }
 
-func isAlertResumed(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isAlertResumed(ctx context.Context, kubeClient client.Client,
+	namespacedName types.NamespacedName, alert *notificationv1.Alert) wait.ConditionFunc {
 	return func() (bool, error) {
-		var alert notificationv1.Alert
-		namespacedName := types.NamespacedName{
-			Namespace: namespace,
-			Name:      name,
-		}
-
-		err := kubeClient.Get(ctx, namespacedName, &alert)
+		err := kubeClient.Get(ctx, namespacedName, alert)
 		if err != nil {
 			return false, err
 		}
diff --git a/cmd/gotk/resume_helmrelease.go b/cmd/gotk/resume_helmrelease.go
index 2484b0dde0e4b56354450e29ff0661749a9a3fb1..46f9c4ba99cc4514ad266e44bd12d4fae05bc376 100644
--- a/cmd/gotk/resume_helmrelease.go
+++ b/cmd/gotk/resume_helmrelease.go
@@ -79,36 +79,25 @@ func resumeHrCmdRun(cmd *cobra.Command, args []string) error {
 
 	logger.Waitingf("waiting for HelmRelease reconciliation")
 	if err := wait.PollImmediate(pollInterval, timeout,
-		isHelmReleaseResumed(ctx, kubeClient, name, namespace)); err != nil {
+		isHelmReleaseResumed(ctx, kubeClient, namespacedName, &helmRelease)); err != nil {
 		return err
 	}
-
 	logger.Successf("HelmRelease reconciliation completed")
 
-	err = kubeClient.Get(ctx, namespacedName, &helmRelease)
-	if err != nil {
-		return err
-	}
-
-	if helmRelease.Status.LastAppliedRevision != "" {
-		logger.Successf("applied revision %s", helmRelease.Status.LastAppliedRevision)
-	} else {
-		return fmt.Errorf("HelmRelease reconciliation failed")
-	}
-
+	logger.Successf("applied revision %s", helmRelease.Status.LastAppliedRevision)
 	return nil
 }
 
-func isHelmReleaseResumed(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isHelmReleaseResumed(ctx context.Context, kubeClient client.Client,
+	namespacedName types.NamespacedName, helmRelease *helmv2.HelmRelease) wait.ConditionFunc {
 	return func() (bool, error) {
-		var helmRelease helmv2.HelmRelease
-		namespacedName := types.NamespacedName{
-			Namespace: namespace,
-			Name:      name,
+		err := kubeClient.Get(ctx, namespacedName, helmRelease)
+		if err != nil {
+			return false, err
 		}
 
-		err := kubeClient.Get(ctx, namespacedName, &helmRelease)
-		if err != nil {
+		// Confirm the state we are observing is for the current generation
+		if helmRelease.Generation != helmRelease.Status.ObservedGeneration {
 			return false, err
 		}
 
diff --git a/cmd/gotk/resume_kustomization.go b/cmd/gotk/resume_kustomization.go
index faef0e6420125e8efebe1f28286d8b38620d1fa6..b683defbe4035160eb49a38d643f2735a76145cf 100644
--- a/cmd/gotk/resume_kustomization.go
+++ b/cmd/gotk/resume_kustomization.go
@@ -47,7 +47,7 @@ func init() {
 
 func resumeKsCmdRun(cmd *cobra.Command, args []string) error {
 	if len(args) < 1 {
-		return fmt.Errorf("kustomization name is required")
+		return fmt.Errorf("Kustomization name is required")
 	}
 	name := args[0]
 
@@ -69,48 +69,37 @@ func resumeKsCmdRun(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	logger.Actionf("resuming kustomization %s in %s namespace", name, namespace)
+	logger.Actionf("resuming Kustomization %s in %s namespace", name, namespace)
 	kustomization.Spec.Suspend = false
 	if err := kubeClient.Update(ctx, &kustomization); err != nil {
 		return err
 	}
-	logger.Successf("kustomization resumed")
+	logger.Successf("Kustomization resumed")
 
-	logger.Waitingf("waiting for kustomization sync")
+	logger.Waitingf("waiting for Kustomization reconciliation")
 	if err := wait.PollImmediate(pollInterval, timeout,
-		isKustomizationResumed(ctx, kubeClient, name, namespace)); err != nil {
+		isKustomizationResumed(ctx, kubeClient, namespacedName, &kustomization)); err != nil {
 		return err
 	}
+	logger.Successf("Kustomization reconciliation completed")
 
-	logger.Successf("kustomization sync completed")
-
-	err = kubeClient.Get(ctx, namespacedName, &kustomization)
-	if err != nil {
-		return err
-	}
-
-	if kustomization.Status.LastAppliedRevision != "" {
-		logger.Successf("applied revision %s", kustomization.Status.LastAppliedRevision)
-	} else {
-		return fmt.Errorf("kustomization sync failed")
-	}
-
+	logger.Successf("applied revision %s", kustomization.Status.LastAppliedRevision)
 	return nil
 }
 
-func isKustomizationResumed(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isKustomizationResumed(ctx context.Context, kubeClient client.Client,
+	namespacedName types.NamespacedName, kustomization *kustomizev1.Kustomization) wait.ConditionFunc {
 	return func() (bool, error) {
-		var kustomization kustomizev1.Kustomization
-		namespacedName := types.NamespacedName{
-			Namespace: namespace,
-			Name:      name,
-		}
-
-		err := kubeClient.Get(ctx, namespacedName, &kustomization)
+		err := kubeClient.Get(ctx, namespacedName, kustomization)
 		if err != nil {
 			return false, err
 		}
 
+		// Confirm the state we are observing is for the current generation
+		if kustomization.Generation != kustomization.Status.ObservedGeneration {
+			return false, nil
+		}
+
 		if c := meta.GetCondition(kustomization.Status.Conditions, meta.ReadyCondition); c != nil {
 			switch c.Status {
 			case corev1.ConditionTrue:
diff --git a/cmd/gotk/resume_receiver.go b/cmd/gotk/resume_receiver.go
index 14f30e70f817069591613096403224b81b7c2cd6..25c40daa61c1a8ca36a0e463bc612bd4249c9585 100644
--- a/cmd/gotk/resume_receiver.go
+++ b/cmd/gotk/resume_receiver.go
@@ -78,24 +78,18 @@ func resumeReceiverCmdRun(cmd *cobra.Command, args []string) error {
 
 	logger.Waitingf("waiting for Receiver reconciliation")
 	if err := wait.PollImmediate(pollInterval, timeout,
-		isReceiverResumed(ctx, kubeClient, name, namespace)); err != nil {
+		isReceiverResumed(ctx, kubeClient, namespacedName, &receiver)); err != nil {
 		return err
 	}
 
 	logger.Successf("Receiver reconciliation completed")
-
 	return nil
 }
 
-func isReceiverResumed(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isReceiverResumed(ctx context.Context, kubeClient client.Client,
+	namespacedName types.NamespacedName, receiver *notificationv1.Receiver) wait.ConditionFunc {
 	return func() (bool, error) {
-		var receiver notificationv1.Receiver
-		namespacedName := types.NamespacedName{
-			Namespace: namespace,
-			Name:      name,
-		}
-
-		err := kubeClient.Get(ctx, namespacedName, &receiver)
+		err := kubeClient.Get(ctx, namespacedName, receiver)
 		if err != nil {
 			return false, err
 		}
diff --git a/docs/cmd/gotk_create_helmrelease.md b/docs/cmd/gotk_create_helmrelease.md
index 06eec7313c209317cfec35ff81d0d2e5fe254291..9a831bec885fd6dc7705d4d1a1ea766d8e61abf4 100644
--- a/docs/cmd/gotk_create_helmrelease.md
+++ b/docs/cmd/gotk_create_helmrelease.md
@@ -66,7 +66,7 @@ gotk create helmrelease [name] [flags]
       --chart-version string      Helm chart version, accepts a semver range (ignored for charts from GitRepository sources)
       --depends-on stringArray    HelmReleases that must be ready before this release can be installed, supported formats '<name>' and '<namespace>/<name>'
   -h, --help                      help for helmrelease
-      --release-name string       name used for the Helm release, defaults to a composition of '[<target-namespace>-]<hr-name>'
+      --release-name string       name used for the Helm release, defaults to a composition of '[<target-namespace>-]<HelmRelease-name>'
       --source string             source that contains the chart (<kind>/<name>)
       --target-namespace string   namespace to install this release, defaults to the HelmRelease namespace
       --values string             local path to the values.yaml file
diff --git a/docs/cmd/gotk_reconcile_kustomization.md b/docs/cmd/gotk_reconcile_kustomization.md
index d455e02b914d31191af9f613f87047f63f91f69b..b9aa6dd823b01c466c104c31fd65b752da22b4f7 100644
--- a/docs/cmd/gotk_reconcile_kustomization.md
+++ b/docs/cmd/gotk_reconcile_kustomization.md
@@ -26,7 +26,7 @@ gotk reconcile kustomization [name] [flags]
 
 ```
   -h, --help          help for kustomization
-      --with-source   reconcile kustomization source
+      --with-source   reconcile Kustomization source
 ```
 
 ### Options inherited from parent commands
diff --git a/docs/guides/installation.md b/docs/guides/installation.md
index 5f6fb80b3200e0783ac7896f6c538fe0ea0025d1..589d23479d9d61d5cd51c5353832b5b8b81c4678 100644
--- a/docs/guides/installation.md
+++ b/docs/guides/installation.md
@@ -166,9 +166,9 @@ gotk bootstrap gitlab \
 ```
 
 !!! hint "Authentication"
-    When providing the `--ssh-hostname`, a readonly deploy key will be added 
+    When providing the `--ssh-hostname`, a read-only (SSH) deploy key will be added 
     to your repository, otherwise your GitLab personal token will be used to
-    authenticate against the HTTPS endpoint instead of SSH.
+    authenticate against the HTTPS endpoint instead.
 
 Run the bootstrap for a repository owned by a GitLab group:
 
diff --git a/go.mod b/go.mod
index 6f4015ad220bde69557a62cbf2abb220af512e1c..2c8cdf1cefd432444ae6a5f14275442bf0da408d 100644
--- a/go.mod
+++ b/go.mod
@@ -4,8 +4,8 @@ go 1.15
 
 require (
 	github.com/blang/semver/v4 v4.0.0
-	github.com/fluxcd/helm-controller/api v0.1.2
-	github.com/fluxcd/kustomize-controller/api v0.1.1
+	github.com/fluxcd/helm-controller/api v0.1.3
+	github.com/fluxcd/kustomize-controller/api v0.1.2
 	github.com/fluxcd/notification-controller/api v0.1.1
 	github.com/fluxcd/pkg/apis/meta v0.0.2
 	github.com/fluxcd/pkg/git v0.0.7
diff --git a/go.sum b/go.sum
index 08c1a56e03682d3c3b391523b00d67f68876fe75..4cfbab6444b9905f99cff42046d981c366755231 100644
--- a/go.sum
+++ b/go.sum
@@ -111,10 +111,10 @@ github.com/evanphx/json-patch v4.5.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLi
 github.com/evanphx/json-patch v4.9.0+incompatible h1:kLcOMZeuLAJvL2BPWLMIj5oaZQobrkAqrL+WFZwQses=
 github.com/evanphx/json-patch v4.9.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
-github.com/fluxcd/helm-controller/api v0.1.2 h1:gBky+nMpDaUT8mhLSaRkHEWczOvLR/JT6L5iRhu4CIs=
-github.com/fluxcd/helm-controller/api v0.1.2/go.mod h1:eMkEzQrgDnOFa/iUey4VVjdqmPJFwcWb+3SFPDX9lJ0=
-github.com/fluxcd/kustomize-controller/api v0.1.1 h1:hg9koO2YD5VLetwT/Xsaq4MWJ5uXKdjKhx9xDFOJxmo=
-github.com/fluxcd/kustomize-controller/api v0.1.1/go.mod h1:84YzQnJ2DShfIE842HYHqB48i0vhpZMJ9XQsdgOEkfM=
+github.com/fluxcd/helm-controller/api v0.1.3 h1:OztoSyxj5+2P38FRc9JXqnXP+f4eNQ0j199PRIqhnR4=
+github.com/fluxcd/helm-controller/api v0.1.3/go.mod h1:eMkEzQrgDnOFa/iUey4VVjdqmPJFwcWb+3SFPDX9lJ0=
+github.com/fluxcd/kustomize-controller/api v0.1.2 h1:gocCnhlqTjzZy7DbTdA2QezFMdudfIXv5RRAP4D5lfc=
+github.com/fluxcd/kustomize-controller/api v0.1.2/go.mod h1:MztOqUKfKn/CBzRofBMq/DAOjzQSoDTmFdIKR32BEQg=
 github.com/fluxcd/notification-controller/api v0.1.1 h1:tu6+bi28vfHoSp2MUD9h42SIvqY+YtEwS9toH9k7cRA=
 github.com/fluxcd/notification-controller/api v0.1.1/go.mod h1:w1gILYTSqt3dFMYRmCihA/K84yDBfIkL5m5dcbaUyUY=
 github.com/fluxcd/pkg/apis/meta v0.0.2 h1:kyA4Y0IzNjf1joBOnFqpWG7aNDHvtLExZcaHQM7qhRI=
diff --git a/manifests/bases/helm-controller/kustomization.yaml b/manifests/bases/helm-controller/kustomization.yaml
index 8dc25356c2511735a7ef8e7eab0eadff4415e149..2e0e811a1aea8dbb90e8c9812381ef15493acc82 100644
--- a/manifests/bases/helm-controller/kustomization.yaml
+++ b/manifests/bases/helm-controller/kustomization.yaml
@@ -1,8 +1,8 @@
 apiVersion: kustomize.config.k8s.io/v1beta1
 kind: Kustomization
 resources:
-- https://github.com/fluxcd/helm-controller/archive/v0.1.2.zip//helm-controller-0.1.2/config/crd
-- https://github.com/fluxcd/helm-controller/archive/v0.1.2.zip//helm-controller-0.1.2/config/manager
+- https://github.com/fluxcd/helm-controller/archive/v0.1.3.zip//helm-controller-0.1.3/config/crd
+- https://github.com/fluxcd/helm-controller/archive/v0.1.3.zip//helm-controller-0.1.3/config/manager
 patchesJson6902:
 - target:
     group: apps
diff --git a/manifests/bases/kustomize-controller/kustomization.yaml b/manifests/bases/kustomize-controller/kustomization.yaml
index d8d7d54b0f45dca5da409e82707b83e448f06372..890467baee8b4b1cb65eaad1c26d23e3a65796d4 100644
--- a/manifests/bases/kustomize-controller/kustomization.yaml
+++ b/manifests/bases/kustomize-controller/kustomization.yaml
@@ -1,8 +1,8 @@
 apiVersion: kustomize.config.k8s.io/v1beta1
 kind: Kustomization
 resources:
-- https://github.com/fluxcd/kustomize-controller/archive/v0.1.1.zip//kustomize-controller-0.1.1/config/crd
-- https://github.com/fluxcd/kustomize-controller/archive/v0.1.1.zip//kustomize-controller-0.1.1/config/manager
+- https://github.com/fluxcd/kustomize-controller/archive/v0.1.2.zip//kustomize-controller-0.1.2/config/crd
+- https://github.com/fluxcd/kustomize-controller/archive/v0.1.2.zip//kustomize-controller-0.1.2/config/manager
 patchesJson6902:
 - target:
     group: apps