diff --git a/fakes/fake_git_hub.go b/fakes/fake_git_hub.go
index 4d69aec..e4e8723 100644
--- a/fakes/fake_git_hub.go
+++ b/fakes/fake_git_hub.go
@@ -54,6 +54,14 @@ type FakeGitHub struct {
 	uploadReleaseAssetReturns struct {
 		result1 error
 	}
+	DeleteReleaseAssetStub        func(asset github.ReleaseAsset) error
+	deleteReleaseAssetMutex       sync.RWMutex
+	deleteReleaseAssetArgsForCall []struct {
+		asset github.ReleaseAsset
+	}
+	deleteReleaseAssetReturns struct {
+		result1 error
+	}
 }
 
 func (fake *FakeGitHub) ListReleases() ([]github.RepositoryRelease, error) {
@@ -214,4 +222,36 @@ func (fake *FakeGitHub) UploadReleaseAssetReturns(result1 error) {
 	}{result1}
 }
 
+func (fake *FakeGitHub) DeleteReleaseAsset(asset github.ReleaseAsset) error {
+	fake.deleteReleaseAssetMutex.Lock()
+	fake.deleteReleaseAssetArgsForCall = append(fake.deleteReleaseAssetArgsForCall, struct {
+		asset github.ReleaseAsset
+	}{asset})
+	fake.deleteReleaseAssetMutex.Unlock()
+	if fake.DeleteReleaseAssetStub != nil {
+		return fake.DeleteReleaseAssetStub(asset)
+	} else {
+		return fake.deleteReleaseAssetReturns.result1
+	}
+}
+
+func (fake *FakeGitHub) DeleteReleaseAssetCallCount() int {
+	fake.deleteReleaseAssetMutex.RLock()
+	defer fake.deleteReleaseAssetMutex.RUnlock()
+	return len(fake.deleteReleaseAssetArgsForCall)
+}
+
+func (fake *FakeGitHub) DeleteReleaseAssetArgsForCall(i int) github.ReleaseAsset {
+	fake.deleteReleaseAssetMutex.RLock()
+	defer fake.deleteReleaseAssetMutex.RUnlock()
+	return fake.deleteReleaseAssetArgsForCall[i].asset
+}
+
+func (fake *FakeGitHub) DeleteReleaseAssetReturns(result1 error) {
+	fake.DeleteReleaseAssetStub = nil
+	fake.deleteReleaseAssetReturns = struct {
+		result1 error
+	}{result1}
+}
+
 var _ resource.GitHub = new(FakeGitHub)
diff --git a/github.go b/github.go
index 1dc725b..24ee37e 100644
--- a/github.go
+++ b/github.go
@@ -18,6 +18,7 @@ type GitHub interface {
 
 	ListReleaseAssets(release *github.RepositoryRelease) ([]github.ReleaseAsset, error)
 	UploadReleaseAsset(release *github.RepositoryRelease, name string, file *os.File) error
+	DeleteReleaseAsset(asset github.ReleaseAsset) error
 }
 
 type GitHubClient struct {
@@ -44,20 +45,30 @@ func NewGitHubClient(source Source) *GitHubClient {
 }
 
 func (g *GitHubClient) ListReleases() ([]github.RepositoryRelease, error) {
-	releases, _, err := g.client.Repositories.ListReleases(g.user, g.repository, nil)
+	releases, res, err := g.client.Repositories.ListReleases(g.user, g.repository, nil)
 	if err != nil {
 		return []github.RepositoryRelease{}, err
 	}
 
+	err = res.Body.Close()
+	if err != nil {
+		return nil, err
+	}
+
 	return releases, nil
 }
 
 func (g *GitHubClient) CreateRelease(release *github.RepositoryRelease) (*github.RepositoryRelease, error) {
-	createdRelease, _, err := g.client.Repositories.CreateRelease(g.user, g.repository, release)
+	createdRelease, res, err := g.client.Repositories.CreateRelease(g.user, g.repository, release)
 	if err != nil {
 		return &github.RepositoryRelease{}, err
 	}
 
+	err = res.Body.Close()
+	if err != nil {
+		return nil, err
+	}
+
 	return createdRelease, nil
 }
 
@@ -66,25 +77,35 @@ func (g *GitHubClient) UpdateRelease(release *github.RepositoryRelease) (*github
 		return nil, errors.New("release did not have an ID: has it been saved yet?")
 	}
 
-	updatedRelease, _, err := g.client.Repositories.EditRelease(g.user, g.repository, *release.ID, release)
+	updatedRelease, res, err := g.client.Repositories.EditRelease(g.user, g.repository, *release.ID, release)
 	if err != nil {
 		return &github.RepositoryRelease{}, err
 	}
 
+	err = res.Body.Close()
+	if err != nil {
+		return nil, err
+	}
+
 	return updatedRelease, nil
 }
 
 func (g *GitHubClient) ListReleaseAssets(release *github.RepositoryRelease) ([]github.ReleaseAsset, error) {
-	assets, _, err := g.client.Repositories.ListReleaseAssets(g.user, g.repository, *release.ID, nil)
+	assets, res, err := g.client.Repositories.ListReleaseAssets(g.user, g.repository, *release.ID, nil)
 	if err != nil {
 		return []github.ReleaseAsset{}, nil
 	}
 
+	err = res.Body.Close()
+	if err != nil {
+		return nil, err
+	}
+
 	return assets, nil
 }
 
 func (g *GitHubClient) UploadReleaseAsset(release *github.RepositoryRelease, name string, file *os.File) error {
-	_, _, err := g.client.Repositories.UploadReleaseAsset(
+	_, res, err := g.client.Repositories.UploadReleaseAsset(
 		g.user,
 		g.repository,
 		*release.ID,
@@ -93,6 +114,18 @@ func (g *GitHubClient) UploadReleaseAsset(release *github.RepositoryRelease, nam
 		},
 		file,
 	)
+	if err != nil {
+		return err
+	}
 
-	return err
+	return res.Body.Close()
+}
+
+func (g *GitHubClient) DeleteReleaseAsset(asset github.ReleaseAsset) error {
+	res, err := g.client.Repositories.DeleteReleaseAsset(g.user, g.repository, *asset.ID)
+	if err != nil {
+		return err
+	}
+
+	return res.Body.Close()
 }
diff --git a/out_command.go b/out_command.go
index 2e8f458..fe3f5bd 100644
--- a/out_command.go
+++ b/out_command.go
@@ -63,6 +63,13 @@ func (c *OutCommand) Run(sourceDir string, request OutRequest) (OutResponse, err
 		existingRelease.Name = github.String(name)
 		existingRelease.Body = github.String(body)
 
+		for _, asset := range existingRelease.Assets {
+			err := c.github.DeleteReleaseAsset(asset)
+			if err != nil {
+				return OutResponse{}, err
+			}
+		}
+
 		release, err = c.github.UpdateRelease(existingRelease)
 	} else {
 		release, err = c.github.CreateRelease(release)
diff --git a/out_command_test.go b/out_command_test.go
index be0e4ea..7541291 100644
--- a/out_command_test.go
+++ b/out_command_test.go
@@ -63,9 +63,18 @@ var _ = Describe("Out Command", func() {
 	})
 
 	Context("when the release has already been created", func() {
+		existingAssets := []github.ReleaseAsset{
+			{ID: github.Int(456789)},
+			{ID: github.Int(3450798)},
+		}
+
 		BeforeEach(func() {
 			githubClient.ListReleasesReturns([]github.RepositoryRelease{
-				{ID: github.Int(112), TagName: github.String("some-tag-name")},
+				{
+					ID:      github.Int(112),
+					TagName: github.String("some-tag-name"),
+					Assets:  existingAssets,
+				},
 			}, nil)
 
 			namePath := filepath.Join(sourcesDir, "name")
@@ -92,6 +101,13 @@ var _ = Describe("Out Command", func() {
 			Ω(*updatedRelease.Name).Should(Equal("v0.3.12"))
 			Ω(*updatedRelease.Body).Should(Equal("this is a great release"))
 		})
+
+		It("deletes the existing assets", func() {
+			Ω(githubClient.DeleteReleaseAssetCallCount()).Should(Equal(2))
+
+			Ω(githubClient.DeleteReleaseAssetArgsForCall(0)).Should(Equal(existingAssets[0]))
+			Ω(githubClient.DeleteReleaseAssetArgsForCall(1)).Should(Equal(existingAssets[1]))
+		})
 	})
 
 	Context("when the release has not already been created", func() {