diff --git a/lib/bundler.rb b/lib/bundler.rb
index 5d57342d590..d0ae9132160 100644
--- a/lib/bundler.rb
+++ b/lib/bundler.rb
@@ -60,8 +60,6 @@ module Bundler
   autoload :VersionRanges,          "bundler/version_ranges"
 
   class << self
-    attr_writer :bundle_path
-
     def configure
       @configured ||= configure_gem_home_and_path
     end
@@ -233,7 +231,7 @@ def app_config_path
 
     def app_cache(custom_path = nil)
       path = custom_path || root
-      path.join(settings.app_cache_path)
+      Pathname.new(path).join(settings.app_cache_path)
     end
 
     def tmp(name = Process.pid.to_s)
diff --git a/lib/bundler/cli.rb b/lib/bundler/cli.rb
index c1fc40ab1fc..cd4391279a6 100644
--- a/lib/bundler/cli.rb
+++ b/lib/bundler/cli.rb
@@ -30,7 +30,7 @@ def initialize(*args)
         Bundler.reset_paths!
       end
 
-      Bundler.settings[:retry] = options[:retry] if options[:retry]
+      Bundler.settings.set_command_option_if_given :retry, options[:retry]
 
       current_cmd = args.last[:current_command].name
       auto_install if AUTO_INSTALL_CMDS.include?(current_cmd)
@@ -38,7 +38,6 @@ def initialize(*args)
       raise InvalidOption, e.message
     ensure
       self.options ||= {}
-      Bundler.settings.cli_flags_given = !options.empty?
       unprinted_warnings = Bundler.ui.unprinted_warnings
       Bundler.ui = UI::Shell.new(options)
       Bundler.ui.level = "debug" if options["verbose"]
@@ -53,6 +52,11 @@ def initialize(*args)
       end
     end
 
+    def self.deprecated_option(*args, &blk)
+      return if Bundler.feature_flag.forget_cli_options?
+      method_option(*args, &blk)
+    end
+
     check_unknown_options!(:except => [:config, :exec])
     stop_on_unknown_option! :exec
 
@@ -113,7 +117,7 @@ def self.handle_no_command_error(command, has_namespace = $thor_runner)
       Gemfile to a gem with a gemspec, the --gemspec option will automatically add each
       dependency listed in the gemspec file to the newly created Gemfile.
     D
-    method_option "gemspec", :type => :string, :banner => "Use the specified .gemspec to create the Gemfile"
+    deprecated_option "gemspec", :type => :string, :banner => "Use the specified .gemspec to create the Gemfile"
     def init
       require "bundler/cli/init"
       Init.new(options.dup).run
@@ -130,7 +134,7 @@ def init
     method_option "gemfile", :type => :string, :banner =>
       "Use the specified gemfile instead of Gemfile"
     method_option "path", :type => :string, :banner =>
-      "Specify a different path than the system default ($BUNDLE_PATH or $GEM_HOME). Bundler will remember this value for future installs on this machine"
+      "Specify a different path than the system default ($BUNDLE_PATH or $GEM_HOME).#{" Bundler will remember this value for future installs on this machine" unless Bundler.feature_flag.forget_cli_options?}"
     map "c" => "check"
     def check
       require "bundler/cli/check"
@@ -148,13 +152,13 @@ def check
 
       If the bundle has already been installed, bundler will tell you so and then exit.
     D
-    method_option "binstubs", :type => :string, :lazy_default => "bin", :banner =>
+    deprecated_option "binstubs", :type => :string, :lazy_default => "bin", :banner =>
       "Generate bin stubs for bundled gems to ./bin"
-    method_option "clean", :type => :boolean, :banner =>
+    deprecated_option "clean", :type => :boolean, :banner =>
       "Run bundle clean automatically after install"
-    method_option "deployment", :type => :boolean, :banner =>
+    deprecated_option "deployment", :type => :boolean, :banner =>
       "Install using defaults tuned for deployment environments"
-    method_option "frozen", :type => :boolean, :banner =>
+    deprecated_option "frozen", :type => :boolean, :banner =>
       "Do not allow the Gemfile.lock to be updated after this install"
     method_option "full-index", :type => :boolean, :banner =>
       "Fall back to using the single-file index of all gems"
@@ -164,28 +168,29 @@ def check
       "Specify the number of jobs to run in parallel"
     method_option "local", :type => :boolean, :banner =>
       "Do not attempt to fetch gems remotely and use the gem cache instead"
-    method_option "no-cache", :type => :boolean, :banner =>
+    deprecated_option "no-cache", :type => :boolean, :banner =>
       "Don't update the existing gem cache."
-    method_option "force", :type => :boolean, :banner =>
+    method_option "redownload", :type => :boolean, :aliases =>
+      [Bundler.feature_flag.forget_cli_options? ? nil : "--force"].compact, :banner =>
       "Force downloading every gem."
-    method_option "no-prune", :type => :boolean, :banner =>
+    deprecated_option "no-prune", :type => :boolean, :banner =>
       "Don't remove stale gems from the cache."
-    method_option "path", :type => :string, :banner =>
+    deprecated_option "path", :type => :string, :banner =>
       "Specify a different path than the system default ($BUNDLE_PATH or $GEM_HOME). Bundler will remember this value for future installs on this machine"
     method_option "quiet", :type => :boolean, :banner =>
       "Only output warnings and errors."
-    method_option "shebang", :type => :string, :banner =>
+    deprecated_option "shebang", :type => :string, :banner =>
       "Specify a different shebang executable name than the default (usually 'ruby')"
     method_option "standalone", :type => :array, :lazy_default => [], :banner =>
       "Make a bundle that can work without the Bundler runtime"
-    method_option "system", :type => :boolean, :banner =>
+    deprecated_option "system", :type => :boolean, :banner =>
       "Install to the system location ($BUNDLE_PATH or $GEM_HOME) even if the bundle was previously installed somewhere else for this application"
     method_option "trust-policy", :alias => "P", :type => :string, :banner =>
       "Gem trust policy (like gem install -P). Must be one of " +
         Bundler.rubygems.security_policy_keys.join("|")
-    method_option "without", :type => :array, :banner =>
+    deprecated_option "without", :type => :array, :banner =>
       "Exclude gems that are part of the specified named group."
-    method_option "with", :type => :array, :banner =>
+    deprecated_option "with", :type => :array, :banner =>
       "Include gems that are part of the specified named group."
     map "i" => "install"
     def install
diff --git a/lib/bundler/cli/binstubs.rb b/lib/bundler/cli/binstubs.rb
index ebb2979625e..38863c5e77b 100644
--- a/lib/bundler/cli/binstubs.rb
+++ b/lib/bundler/cli/binstubs.rb
@@ -12,9 +12,10 @@ def initialize(options, gems)
 
     def run
       Bundler.definition.validate_runtime!
-      Bundler.settings[:bin] = options["path"] if options["path"]
-      Bundler.settings[:bin] = nil if options["path"] && options["path"].empty?
-      Bundler.settings[:shebang] = options["shebang"] if options["shebang"]
+      path_option = options["path"]
+      path_option = nil if path_option && path_option.empty?
+      Bundler.settings.set_command_option :bin, path_option if options["path"]
+      Bundler.settings.set_command_option_if_given :shebang, options["shebang"]
       installer = Installer.new(Bundler.root, Bundler.definition)
 
       if gems.empty?
diff --git a/lib/bundler/cli/cache.rb b/lib/bundler/cli/cache.rb
index 891671447d5..77e049e7a24 100644
--- a/lib/bundler/cli/cache.rb
+++ b/lib/bundler/cli/cache.rb
@@ -11,9 +11,9 @@ def run
       Bundler.definition.validate_runtime!
       Bundler.definition.resolve_with_cache!
       setup_cache_all
-      Bundler.settings[:cache_all_platforms] = options["all-platforms"] if options.key?("all-platforms")
+      Bundler.settings.set_command_option_if_given :cache_all_platforms, options["all-platforms"]
       Bundler.load.cache
-      Bundler.settings[:no_prune] = true if options["no-prune"]
+      Bundler.settings.set_command_option_if_given :no_prune, options["no-prune"]
       Bundler.load.lock
     rescue GemNotFound => e
       Bundler.ui.error(e.message)
@@ -24,7 +24,7 @@ def run
   private
 
     def setup_cache_all
-      Bundler.settings[:cache_all] = options[:all] if options.key?("all")
+      Bundler.settings.set_command_option_if_given :cache_all, options[:all]
 
       if Bundler.definition.has_local_dependencies? && !Bundler.settings[:cache_all]
         Bundler.ui.warn "Your Gemfile contains path and git dependencies. If you want "    \
diff --git a/lib/bundler/cli/check.rb b/lib/bundler/cli/check.rb
index 553c48cebfa..c7367b2f42b 100644
--- a/lib/bundler/cli/check.rb
+++ b/lib/bundler/cli/check.rb
@@ -9,9 +9,9 @@ def initialize(options)
     end
 
     def run
-      if options[:path]
-        Bundler.settings[:path] = File.expand_path(options[:path])
-        Bundler.settings[:disable_shared_gems] = true
+      if path = options[:path]
+        Bundler.settings.set_command_option :path, path
+        Bundler.settings.set_command_option :disable_shared_gems, true
       end
 
       begin
diff --git a/lib/bundler/cli/clean.rb b/lib/bundler/cli/clean.rb
index 0534532ee2e..231127cf97f 100644
--- a/lib/bundler/cli/clean.rb
+++ b/lib/bundler/cli/clean.rb
@@ -17,10 +17,9 @@ def run
 
     def require_path_or_force
       if !Bundler.settings[:path] && !options[:force]
-        Bundler.ui.error "Cleaning all the gems on your system is dangerous! " \
+        raise InvalidOption, "Cleaning all the gems on your system is dangerous! " \
           "If you're sure you want to remove every system gem not in this " \
           "bundle, run `bundle clean --force`."
-        exit 1
       end
     end
   end
diff --git a/lib/bundler/cli/common.rb b/lib/bundler/cli/common.rb
index c8c4115fa32..018f7bfdc9d 100644
--- a/lib/bundler/cli/common.rb
+++ b/lib/bundler/cli/common.rb
@@ -15,12 +15,12 @@ def self.print_post_install_message(name, msg)
     end
 
     def self.output_without_groups_message
-      return unless Bundler.settings.without.any?
+      return if Bundler.settings[:without].empty?
       Bundler.ui.confirm without_groups_message
     end
 
     def self.without_groups_message
-      groups = Bundler.settings.without
+      groups = Bundler.settings[:without]
       group_list = [groups[0...-1].join(", "), groups[-1..-1]].
         reject {|s| s.to_s.empty? }.join(" and ")
       group_str = (groups.size == 1) ? "group" : "groups"
diff --git a/lib/bundler/cli/install.rb b/lib/bundler/cli/install.rb
index b9188b233c2..cc41cce7a62 100644
--- a/lib/bundler/cli/install.rb
+++ b/lib/bundler/cli/install.rb
@@ -14,14 +14,6 @@ def run
 
       warn_if_root
 
-      [:with, :without].each do |option|
-        if options[option]
-          options[option] = options[option].join(":").tr(" ", ":").split(":")
-        end
-      end
-
-      check_for_group_conflicts
-
       normalize_groups
 
       Bundler::SharedHelpers.set_env "RB_USER_INSTALL", "1" if Bundler::FREEBSD
@@ -46,15 +38,15 @@ def run
         options[:local] = true if Bundler.app_cache.exist?
 
         if Bundler.feature_flag.deployment_means_frozen?
-          Bundler.settings.temporary(:deployment => true)
+          Bundler.settings.set_command_option :deployment, true
         else
-          Bundler.settings[:frozen] ||= true
+          Bundler.settings.set_command_option :frozen, true
         end
       end
 
       # When install is called with --no-deployment, disable deployment mode
       if options[:deployment] == false
-        Bundler.settings.delete(:frozen)
+        Bundler.settings.set_command_option :frozen, nil
         options[:system] = true
       end
 
@@ -78,8 +70,8 @@ def run
       Bundler.ui.confirm "Bundle complete! #{dependencies_count_for(definition)}, #{gems_installed_for(definition)}."
       Bundler::CLI::Common.output_without_groups_message
 
-      if Bundler.settings[:path]
-        absolute_path = File.expand_path(Bundler.settings[:path])
+      if path = Bundler.settings[:path]
+        absolute_path = File.expand_path(path)
         relative_path = absolute_path.sub(File.expand_path(".") + File::SEPARATOR, "." + File::SEPARATOR)
         Bundler.ui.confirm "Bundled gems are installed into #{relative_path}."
       else
@@ -131,15 +123,11 @@ def gems_installed_for(definition)
       "#{count} #{count == 1 ? "gem" : "gems"} now installed"
     end
 
-    def check_for_group_conflicts
-      if options[:without] && options[:with]
-        conflicting_groups = options[:without] & options[:with]
-        unless conflicting_groups.empty?
-          Bundler.ui.error "You can't list a group in both, --with and --without." \
-          " The offending groups are: #{conflicting_groups.join(", ")}."
-          exit 1
-        end
-      end
+    def check_for_group_conflicts_in_cli_options
+      conflicting_groups = Array(options[:without]) & Array(options[:with])
+      return if conflicting_groups.empty?
+      raise InvalidOption, "You can't list a group in both with and without." \
+        " The offending groups are: #{conflicting_groups.join(", ")}."
     end
 
     def check_for_options_conflicts
@@ -152,28 +140,29 @@ def check_for_options_conflicts
     end
 
     def check_trust_policy
-      if options["trust-policy"]
-        unless Bundler.rubygems.security_policies.keys.include?(options["trust-policy"])
-          Bundler.ui.error "RubyGems doesn't know about trust policy '#{options["trust-policy"]}'. " \
-            "The known policies are: #{Bundler.rubygems.security_policies.keys.join(", ")}."
-          exit 1
-        end
-        Bundler.settings["trust-policy"] = options["trust-policy"]
-      else
-        Bundler.settings["trust-policy"] = nil if Bundler.settings["trust-policy"]
+      trust_policy = options["trust-policy"]
+      unless Bundler.rubygems.security_policies.keys.unshift(nil).include?(trust_policy)
+        raise InvalidOption, "RubyGems doesn't know about trust policy '#{trust_policy}'. " \
+          "The known policies are: #{Bundler.rubygems.security_policies.keys.join(", ")}."
       end
+      Bundler.settings.set_command_option_if_given :"trust-policy", trust_policy
     end
 
     def normalize_groups
-      Bundler.settings.with    = [] if options[:with] && options[:with].empty?
-      Bundler.settings.without = [] if options[:without] && options[:without].empty?
+      options[:with] &&= options[:with].join(":").tr(" ", ":").split(":")
+      options[:without] &&= options[:without].join(":").tr(" ", ":").split(":")
+
+      check_for_group_conflicts_in_cli_options
 
-      with = options.fetch("with", [])
-      with |= Bundler.settings.with.map(&:to_s)
+      Bundler.settings.set_command_option_if_given :with, options[:with]
+      Bundler.settings.set_command_option_if_given :without, options[:without]
+
+      with = options.fetch(:with, [])
+      with |= Bundler.settings[:with].map(&:to_s)
       with -= options[:without] if options[:without]
 
-      without = options.fetch("without", [])
-      without |= Bundler.settings.without.map(&:to_s)
+      without = options.fetch(:without, [])
+      without |= Bundler.settings[:without].map(&:to_s)
       without -= options[:with] if options[:with]
 
       options[:with]    = with
@@ -181,29 +170,32 @@ def normalize_groups
     end
 
     def normalize_settings
-      Bundler.settings[:path]                = nil if options[:system]
-      Bundler.settings[:path]                = "vendor/bundle" if options[:deployment]
-      Bundler.settings[:path]                = options["path"] if options["path"]
-      Bundler.settings[:path]              ||= "bundle" if options["standalone"]
+      Bundler.settings.set_command_option :path, nil if options[:system]
+      Bundler.settings.set_command_option :path, "vendor/bundle" if options[:deployment]
+      Bundler.settings.set_command_option_if_given :path, options["path"]
+      Bundler.settings.set_command_option :path, "bundle" if options["standalone"] && Bundler.settings[:path].nil?
 
-      Bundler.settings[:bin]                 = options["binstubs"] if options["binstubs"]
-      Bundler.settings[:bin]                 = nil if options["binstubs"] && options["binstubs"].empty?
+      bin_option = options["binstubs"]
+      bin_option = nil if bin_option && bin_option.empty?
+      Bundler.settings.set_command_option :bin, bin_option if options["binstubs"]
 
-      Bundler.settings[:shebang]             = options["shebang"] if options["shebang"]
+      Bundler.settings.set_command_option_if_given :shebang, options["shebang"]
 
-      Bundler.settings[:jobs]                = options["jobs"] if options["jobs"]
+      Bundler.settings.set_command_option_if_given :jobs, options["jobs"]
 
-      Bundler.settings[:no_prune]            = true if options["no-prune"]
+      Bundler.settings.set_command_option_if_given :no_prune, options["no-prune"]
 
-      Bundler.settings[:no_install]          = true if options["no-install"]
+      Bundler.settings.set_command_option_if_given :no_install, options["no-install"]
 
-      Bundler.settings[:clean]               = options["clean"] if options["clean"]
+      Bundler.settings.set_command_option_if_given :clean, options["clean"]
 
-      Bundler.settings.without               = options[:without] unless Bundler.settings.without == options[:without]
-      Bundler.settings.with                  = options[:with] unless Bundler.settings.with == options[:with]
+      Bundler.settings.set_command_option :without, options[:without] unless Bundler.settings[:without] == options[:without]
+      Bundler.settings.set_command_option :with,    options[:with]    unless Bundler.settings[:with]    == options[:with]
 
       disable_shared_gems = Bundler.settings[:path] ? true : nil
-      Bundler.settings[:disable_shared_gems] = disable_shared_gems unless Bundler.settings[:disable_shared_gems] == disable_shared_gems
+      Bundler.settings.set_command_option :disable_shared_gems, disable_shared_gems unless Bundler.settings[:disable_shared_gems] == disable_shared_gems
+
+      options[:force] = options[:redownload]
     end
 
     def warn_ambiguous_gems
diff --git a/lib/bundler/cli/package.rb b/lib/bundler/cli/package.rb
index eca7e08342e..cda41ea6233 100644
--- a/lib/bundler/cli/package.rb
+++ b/lib/bundler/cli/package.rb
@@ -10,15 +10,15 @@ def initialize(options)
 
     def run
       Bundler.ui.level = "error" if options[:quiet]
-      Bundler.settings[:path] = File.expand_path(options[:path]) if options[:path]
-      Bundler.settings[:cache_all_platforms] = options["all-platforms"] if options.key?("all-platforms")
-      Bundler.settings[:cache_path] = options["cache-path"] if options.key?("cache-path")
+      Bundler.settings.set_command_option_if_given :path, options[:path]
+      Bundler.settings.set_command_option_if_given :cache_all_platforms, options["all-platforms"]
+      Bundler.settings.set_command_option_if_given :cache_path, options["cache-path"]
 
       setup_cache_all
       install
 
       # TODO: move cache contents here now that all bundles are locked
-      custom_path = Pathname.new(options[:path]) if options[:path]
+      custom_path = Bundler.settings[:path] if options[:path]
       Bundler.load.cache(custom_path)
     end
 
@@ -35,7 +35,7 @@ def install
     end
 
     def setup_cache_all
-      Bundler.settings[:cache_all] = options[:all] if options.key?("all")
+      Bundler.settings.set_command_option_if_given :cache_all, options[:all]
 
       if Bundler.definition.has_local_dependencies? && !Bundler.settings[:cache_all]
         Bundler.ui.warn "Your Gemfile contains path and git dependencies. If you want "    \
diff --git a/lib/bundler/cli/update.rb b/lib/bundler/cli/update.rb
index 952076566f7..c2391fa76d1 100644
--- a/lib/bundler/cli/update.rb
+++ b/lib/bundler/cli/update.rb
@@ -56,7 +56,7 @@ def run
       opts["update"] = true
       opts["local"] = options[:local]
 
-      Bundler.settings[:jobs] = opts["jobs"] if opts["jobs"]
+      Bundler.settings.set_command_option_if_given :jobs, opts["jobs"]
 
       Bundler.definition.validate_runtime!
       installer = Installer.install Bundler.root, Bundler.definition, opts
diff --git a/lib/bundler/definition.rb b/lib/bundler/definition.rb
index a8b37499fda..6726cf95e86 100644
--- a/lib/bundler/definition.rb
+++ b/lib/bundler/definition.rb
@@ -920,7 +920,7 @@ def pinned_spec_names(specs)
     end
 
     def requested_groups
-      groups - Bundler.settings.without - @optional_groups + Bundler.settings.with
+      groups - Bundler.settings[:without] - @optional_groups + Bundler.settings[:with]
     end
 
     def lockfiles_equal?(current, proposed, preserve_unknown_sections)
diff --git a/lib/bundler/endpoint_specification.rb b/lib/bundler/endpoint_specification.rb
index b82f9529ffe..7231a1630e7 100644
--- a/lib/bundler/endpoint_specification.rb
+++ b/lib/bundler/endpoint_specification.rb
@@ -15,6 +15,9 @@ def initialize(name, version, platform, dependencies, metadata = nil)
       @platform     = platform
       @dependencies = dependencies.map {|dep, reqs| build_dependency(dep, reqs) }
 
+      @loaded_from          = nil
+      @remote_specification = nil
+
       parse_metadata(metadata)
     end
 
diff --git a/lib/bundler/feature_flag.rb b/lib/bundler/feature_flag.rb
index 00523eb96e6..9956411a4bd 100644
--- a/lib/bundler/feature_flag.rb
+++ b/lib/bundler/feature_flag.rb
@@ -34,6 +34,7 @@ def self.settings_method(name, key, &default)
     settings_flag(:deployment_means_frozen) { bundler_2_mode? }
     settings_flag(:disable_multisource) { bundler_2_mode? }
     settings_flag(:error_on_stderr) { bundler_2_mode? }
+    settings_flag(:forget_cli_options) { bundler_2_mode? }
     settings_flag(:global_gem_cache) { bundler_2_mode? }
     settings_flag(:init_gems_rb) { bundler_2_mode? }
     settings_flag(:lockfile_uses_separate_rubygems_sources) { bundler_2_mode? }
diff --git a/lib/bundler/installer.rb b/lib/bundler/installer.rb
index db826601763..5996d185da6 100644
--- a/lib/bundler/installer.rb
+++ b/lib/bundler/installer.rb
@@ -151,7 +151,10 @@ def generate_bundler_executable_stubs(spec, options = {})
     def generate_standalone_bundler_executable_stubs(spec)
       # double-assignment to avoid warnings about variables that will be used by ERB
       bin_path = Bundler.bin_path
-      standalone_path = standalone_path = Bundler.root.join(Bundler.settings[:path]).relative_path_from(bin_path)
+      unless path = Bundler.settings[:path]
+        raise "Can't standalone without a path set"
+      end
+      standalone_path = standalone_path = Bundler.root.join(path).relative_path_from(bin_path)
       template = File.read(File.expand_path("../templates/Executable.standalone", __FILE__))
       ruby_command = ruby_command = Thor::Util.ruby_command
 
diff --git a/lib/bundler/installer/gem_installer.rb b/lib/bundler/installer/gem_installer.rb
index a9bd0f56a5e..086b763d207 100644
--- a/lib/bundler/installer/gem_installer.rb
+++ b/lib/bundler/installer/gem_installer.rb
@@ -66,6 +66,7 @@ def out_of_space_message
     end
 
     def generate_executable_stubs
+      return if Bundler.feature_flag.forget_cli_options?
       return if Bundler.settings[:inline]
       if Bundler.settings[:bin] && standalone
         installer.generate_standalone_bundler_executable_stubs(spec)
diff --git a/lib/bundler/settings.rb b/lib/bundler/settings.rb
index 96e67bfdb45..fa1483f8044 100644
--- a/lib/bundler/settings.rb
+++ b/lib/bundler/settings.rb
@@ -25,6 +25,7 @@ class Settings
       disable_version_check
       error_on_stderr
       force_ruby_platform
+      forget_cli_options
       frozen
       gem.coc
       gem.mit
@@ -54,25 +55,27 @@ class Settings
       timeout
     ].freeze
 
+    ARRAY_KEYS = %w[
+      with
+      without
+    ].freeze
+
     DEFAULT_CONFIG = {
       :redirect => 5,
       :retry => 3,
       :timeout => 10,
     }.freeze
 
-    attr_accessor :cli_flags_given
-
     def initialize(root = nil)
       @root            = root
       @local_config    = load_config(local_config_file)
       @global_config   = load_config(global_config_file)
-      @cli_flags_given = false
       @temporary       = {}
     end
 
     def [](name)
       key = key_for(name)
-      value = @temporary.fetch(name) do
+      value = @temporary.fetch(key) do
               @local_config.fetch(key) do
               ENV.fetch(key) do
               @global_config.fetch(key) do
@@ -83,10 +86,11 @@ def [](name)
       converted_value(value, name)
     end
 
-    def []=(key, value)
-      local_config_file || raise(GemfileNotFound, "Could not locate Gemfile")
-
-      if cli_flags_given
+    def set_command_option(key, value)
+      if Bundler.feature_flag.forget_cli_options?
+        temporary(key => value)
+        value
+      else
         command = if value.nil?
           "bundle config --delete #{key}"
         else
@@ -98,27 +102,35 @@ def []=(key, value)
           "will no longer be automatically remembered. Instead please set flags " \
           "you want remembered between commands using `bundle config " \
           "<setting name> <setting value>`, i.e. `#{command}`"
+
+        set_local(key, value)
       end
+    end
+
+    def set_command_option_if_given(key, value)
+      return if value.nil?
+      set_command_option(key, value)
+    end
+
+    def set_local(key, value)
+      local_config_file || raise(GemfileNotFound, "Could not locate Gemfile")
 
       set_key(key, value, @local_config, local_config_file)
     end
-    alias_method :set_local, :[]=
 
     def temporary(update)
-      existing = Hash[update.map {|k, _| [k, @temporary[k]] }]
-      @temporary.update(update)
+      existing = Hash[update.map {|k, _| [k, @temporary[key_for(k)]] }]
+      update.each do |k, v|
+        set_key(k, v, @temporary, nil)
+      end
       return unless block_given?
       begin
         yield
       ensure
-        existing.each {|k, v| v.nil? ? @temporary.delete(k) : @temporary[k] = v }
+        existing.each {|k, v| set_key(k, v, @temporary, nil) }
       end
     end
 
-    def delete(key)
-      @local_config.delete(key_for(key))
-    end
-
     def set_global(key, value)
       set_key(key, value, @global_config, global_config_file)
     end
@@ -126,7 +138,7 @@ def set_global(key, value)
     def all
       env_keys = ENV.keys.grep(/\ABUNDLE_.+/)
 
-      keys = @global_config.keys | @local_config.keys | env_keys
+      keys = @temporary.keys | @global_config.keys | @local_config.keys | env_keys
 
       keys.map do |key|
         key.sub(/^BUNDLE_/, "").gsub(/__/, ".").downcase
@@ -160,6 +172,7 @@ def gem_mirrors
     def locations(key)
       key = key_for(key)
       locations = {}
+      locations[:temporary] = @temporary[key] if @temporary.key?(key)
       locations[:local]  = @local_config[key] if @local_config.key?(key)
       locations[:env]    = ENV[key] if ENV[key]
       locations[:global] = @global_config[key] if @global_config.key?(key)
@@ -171,6 +184,11 @@ def pretty_values_for(exposed_key)
       key = key_for(exposed_key)
 
       locations = []
+
+      if @temporary.key?(key)
+        locations << "Set for the current command: #{converted_value(@temporary[key], exposed_key).inspect}"
+      end
+
       if @local_config.key?(key)
         locations << "Set for your local app (#{local_config_file}): #{converted_value(@local_config[key], exposed_key).inspect}"
       end
@@ -187,22 +205,6 @@ def pretty_values_for(exposed_key)
       locations
     end
 
-    def without=(array)
-      set_array(:without, array)
-    end
-
-    def with=(array)
-      set_array(:with, array)
-    end
-
-    def without
-      get_array(:without)
-    end
-
-    def with
-      get_array(:with)
-    end
-
     # @local_config["BUNDLE_PATH"] should be prioritized over ENV["BUNDLE_PATH"]
     def path
       key  = key_for(:path)
@@ -261,28 +263,39 @@ def to_bool(value)
       end
     end
 
-    def is_num(value)
-      NUMBER_KEYS.include?(value.to_s)
+    def is_num(key)
+      NUMBER_KEYS.include?(key.to_s)
     end
 
-    def get_array(key)
-      self[key] ? self[key].split(":").map(&:to_sym) : []
+    def is_array(key)
+      ARRAY_KEYS.include?(key.to_s)
     end
 
-    def set_array(key, array)
-      self[key] = (array.empty? ? nil : array.join(":")) if array
+    def to_array(value)
+      return [] unless value
+      value.split(":").map(&:to_sym)
+    end
+
+    def array_to_s(array)
+      array = Array(array)
+      return nil if array.empty?
+      array.join(":").tr(" ", ":")
     end
 
     def set_key(key, value, hash, file)
+      value = array_to_s(value) if is_array(key)
+
       key = key_for(key)
 
       unless hash[key] == value
         hash[key] = value
         hash.delete(key) if value.nil?
-        SharedHelpers.filesystem_access(file) do |p|
-          FileUtils.mkdir_p(p.dirname)
-          require "bundler/yaml_serializer"
-          p.open("w") {|f| f.write(YAMLSerializer.dump(hash)) }
+        if file
+          SharedHelpers.filesystem_access(file) do |p|
+            FileUtils.mkdir_p(p.dirname)
+            require "bundler/yaml_serializer"
+            p.open("w") {|f| f.write(YAMLSerializer.dump(hash)) }
+          end
         end
       end
 
@@ -290,14 +303,16 @@ def set_key(key, value, hash, file)
     end
 
     def converted_value(value, key)
-      if value.nil?
+      if is_array(key)
+        to_array(value)
+      elsif value.nil?
         nil
       elsif is_bool(key) || value == "false"
         to_bool(value)
       elsif is_num(key)
         value.to_i
       else
-        value
+        value.to_s
       end
     end
 
diff --git a/lib/bundler/source/git/git_proxy.rb b/lib/bundler/source/git/git_proxy.rb
index 5b09b52a601..30ab5edf0d5 100644
--- a/lib/bundler/source/git/git_proxy.rb
+++ b/lib/bundler/source/git/git_proxy.rb
@@ -153,7 +153,7 @@ def git_null(command)
         end
 
         def git_retry(command)
-          Bundler::Retry.new("`git #{command}`", GitNotAllowedError).attempts do
+          Bundler::Retry.new("`git #{URICredentialsFilter.credential_filtered_string(command, uri)}`", GitNotAllowedError).attempts do
             git(command)
           end
         end
diff --git a/lib/bundler/yaml_serializer.rb b/lib/bundler/yaml_serializer.rb
index 3c9eccafc2e..0fd81c40eff 100644
--- a/lib/bundler/yaml_serializer.rb
+++ b/lib/bundler/yaml_serializer.rb
@@ -37,7 +37,7 @@ def dump_hash(hash)
     HASH_REGEX = /
       ^
       ([ ]*) # indentations
-      (.*) # key
+      (.+) # key
       (?::(?=(?:\s|$))) # :  (without the lookahead the #key includes this when : is present in value)
       [ ]?
       (?: !\s)? # optional exclamation mark found with ruby 1.9.3
@@ -54,10 +54,10 @@ def load(str)
       last_empty_key = nil
       str.split(/\r?\n/).each do |line|
         if match = HASH_REGEX.match(line)
-          indent, key, _, val = match.captures
+          indent, key, quote, val = match.captures
           key = convert_to_backward_compatible_key(key)
           depth = indent.scan(/  /).length
-          if val.empty?
+          if quote.empty? && val.empty?
             new_hash = {}
             stack[depth][key] = new_hash
             stack[depth + 1] = new_hash
diff --git a/man/bundle-config.ronn b/man/bundle-config.ronn
index 42fb69465a2..f1ba87dfd69 100644
--- a/man/bundle-config.ronn
+++ b/man/bundle-config.ronn
@@ -71,6 +71,9 @@ The options that can be configured are:
 * `without`:
    A space-separated list of groups referencing gems to skip during installation.
 
+* `with`:
+  A space-separated list of groups referencing gems to include during installation.
+
 ## BUILD OPTIONS
 
 You can use `bundle config` to give bundler the flags to pass to the gem
@@ -253,6 +256,8 @@ learn more about their operation in [bundle install(1)][bundle-install].
    and disallow passing no options to `bundle update`.
 * `user_agent` (`BUNDLE_USER_AGENT`):
    The custom user agent fragment Bundler includes in API requests.
+* `with` (`BUNDLE_WITH`):
+   A `:`-separated list of groups whose gems bundler should install.
 * `without` (`BUNDLE_WITHOUT`):
    A `:`-separated list of groups whose gems bundler should not install.
 
diff --git a/spec/bundler/installer/gem_installer_spec.rb b/spec/bundler/installer/gem_installer_spec.rb
index c0eb0a0fecf..7340a3acc0a 100644
--- a/spec/bundler/installer/gem_installer_spec.rb
+++ b/spec/bundler/installer/gem_installer_spec.rb
@@ -20,6 +20,7 @@
     it "invokes install method with build_args", :rubygems => ">= 2" do
       allow(Bundler.settings).to receive(:[]).with(:bin)
       allow(Bundler.settings).to receive(:[]).with(:inline)
+      allow(Bundler.settings).to receive(:[]).with(:forget_cli_options)
       allow(Bundler.settings).to receive(:[]).with("build.dummy").and_return("--with-dummy-config=dummy")
       expect(spec_source).to receive(:install).with(spec, :force => false, :ensure_builtin_gems_cached => false, :build_args => ["--with-dummy-config=dummy"])
       subject.install_from_spec
diff --git a/spec/bundler/settings_spec.rb b/spec/bundler/settings_spec.rb
index 378013c4441..1a31493e201 100644
--- a/spec/bundler/settings_spec.rb
+++ b/spec/bundler/settings_spec.rb
@@ -40,7 +40,7 @@
 
     before do
       hash.each do |key, value|
-        settings[key] = value
+        settings.set_local key, value
       end
     end
 
@@ -100,12 +100,12 @@
 
     context "when is boolean" do
       it "returns a boolean" do
-        settings[:frozen] = "true"
+        settings.set_local :frozen, "true"
         expect(settings[:frozen]).to be true
       end
       context "when specific gem is configured" do
         it "returns a boolean" do
-          settings["ignore_messages.foobar"] = "true"
+          settings.set_local "ignore_messages.foobar", "true"
           expect(settings["ignore_messages.foobar"]).to be true
         end
       end
@@ -113,7 +113,7 @@
 
     context "when is number" do
       it "returns a number" do
-        settings[:ssl_verify_mode] = "1"
+        settings.set_local :ssl_verify_mode, "1"
         expect(settings[:ssl_verify_mode]).to be 1
       end
     end
@@ -122,7 +122,7 @@
       it "raises an PermissionError with explanation" do
         expect(bundler_fileutils).to receive(:mkdir_p).with(settings.send(:local_config_file).dirname).
           and_raise(Errno::EACCES)
-        expect { settings[:frozen] = "1" }.
+        expect { settings.set_local :frozen, "1" }.
           to raise_error(Bundler::PermissionError, /config/)
       end
     end
@@ -130,7 +130,7 @@
 
   describe "#temporary" do
     it "reset after used" do
-      Bundler.settings[:no_install] = true
+      Bundler.settings.set_local :no_install, true
 
       Bundler.settings.temporary(:no_install => false) do
         expect(Bundler.settings[:no_install]).to eq false
@@ -147,7 +147,7 @@
     context "when called without a block" do
       it "leaves the setting changed" do
         Bundler.settings.temporary(:foo => :random)
-        expect(Bundler.settings[:foo]).to eq :random
+        expect(Bundler.settings[:foo]).to eq "random"
       end
 
       it "returns nil" do
@@ -170,7 +170,7 @@
   describe "#pretty_values_for" do
     it "prints the converted value rather than the raw string" do
       bool_key = described_class::BOOL_KEYS.first
-      settings[bool_key] = false
+      settings.set_local(bool_key, "false")
       expect(subject.pretty_values_for(bool_key)).to eq [
         "Set for your local app (#{bundled_app("config")}): false",
       ]
@@ -193,7 +193,7 @@
     context "with a configured mirror" do
       let(:mirror_uri) { URI("https://rubygems-mirror.org/") }
 
-      before { settings["mirror.https://rubygems.org/"] = mirror_uri.to_s }
+      before { settings.set_local "mirror.https://rubygems.org/", mirror_uri.to_s }
 
       it "returns the mirror URI" do
         expect(settings.mirror_for(uri)).to eq(mirror_uri)
@@ -240,7 +240,7 @@
     end
 
     context "with credentials configured by URL" do
-      before { settings["https://gemserver.example.org/"] = credentials }
+      before { settings.set_local "https://gemserver.example.org/", credentials }
 
       it "returns the configured credentials" do
         expect(settings.credentials_for(uri)).to eq(credentials)
@@ -248,7 +248,7 @@
     end
 
     context "with credentials configured by hostname" do
-      before { settings["gemserver.example.org"] = credentials }
+      before { settings.set_local "gemserver.example.org", credentials }
 
       it "returns the configured credentials" do
         expect(settings.credentials_for(uri)).to eq(credentials)
@@ -258,49 +258,49 @@
 
   describe "URI normalization" do
     it "normalizes HTTP URIs in credentials configuration" do
-      settings["http://gemserver.example.org"] = "username:password"
+      settings.set_local "http://gemserver.example.org", "username:password"
       expect(settings.all).to include("http://gemserver.example.org/")
     end
 
     it "normalizes HTTPS URIs in credentials configuration" do
-      settings["https://gemserver.example.org"] = "username:password"
+      settings.set_local "https://gemserver.example.org", "username:password"
       expect(settings.all).to include("https://gemserver.example.org/")
     end
 
     it "normalizes HTTP URIs in mirror configuration" do
-      settings["mirror.http://rubygems.org"] = "http://rubygems-mirror.org"
+      settings.set_local "mirror.http://rubygems.org", "http://rubygems-mirror.org"
       expect(settings.all).to include("mirror.http://rubygems.org/")
     end
 
     it "normalizes HTTPS URIs in mirror configuration" do
-      settings["mirror.https://rubygems.org"] = "http://rubygems-mirror.org"
+      settings.set_local "mirror.https://rubygems.org", "http://rubygems-mirror.org"
       expect(settings.all).to include("mirror.https://rubygems.org/")
     end
 
     it "does not normalize other config keys that happen to contain 'http'" do
-      settings["local.httparty"] = home("httparty")
+      settings.set_local "local.httparty", home("httparty")
       expect(settings.all).to include("local.httparty")
     end
 
     it "does not normalize other config keys that happen to contain 'https'" do
-      settings["local.httpsmarty"] = home("httpsmarty")
+      settings.set_local "local.httpsmarty", home("httpsmarty")
       expect(settings.all).to include("local.httpsmarty")
     end
 
     it "reads older keys without trailing slashes" do
-      settings["mirror.https://rubygems.org"] = "http://rubygems-mirror.org"
+      settings.set_local "mirror.https://rubygems.org", "http://rubygems-mirror.org"
       expect(settings.mirror_for("https://rubygems.org/")).to eq(
         URI("http://rubygems-mirror.org/")
       )
     end
 
     it "normalizes URIs with a fallback_timeout option" do
-      settings["mirror.https://rubygems.org/.fallback_timeout"] = "true"
+      settings.set_local "mirror.https://rubygems.org/.fallback_timeout", "true"
       expect(settings.all).to include("mirror.https://rubygems.org/.fallback_timeout")
     end
 
     it "normalizes URIs with a fallback_timeout option without a trailing slash" do
-      settings["mirror.https://rubygems.org.fallback_timeout"] = "true"
+      settings.set_local "mirror.https://rubygems.org.fallback_timeout", "true"
       expect(settings.all).to include("mirror.https://rubygems.org/.fallback_timeout")
     end
   end
diff --git a/spec/bundler/source/git/git_proxy_spec.rb b/spec/bundler/source/git/git_proxy_spec.rb
index e7187082eae..d282a449a50 100644
--- a/spec/bundler/source/git/git_proxy_spec.rb
+++ b/spec/bundler/source/git/git_proxy_spec.rb
@@ -6,25 +6,25 @@
 
   context "with configured credentials" do
     it "adds username and password to URI" do
-      Bundler.settings[uri] = "u:p"
+      Bundler.settings.temporary(uri => "u:p")
       expect(subject).to receive(:git_retry).with(match("https://u:p@github.com/bundler/bundler.git"))
       subject.checkout
     end
 
     it "adds username and password to URI for host" do
-      Bundler.settings["github.com"] = "u:p"
+      Bundler.settings.temporary("github.com" => "u:p")
       expect(subject).to receive(:git_retry).with(match("https://u:p@github.com/bundler/bundler.git"))
       subject.checkout
     end
 
     it "does not add username and password to mismatched URI" do
-      Bundler.settings["https://u:p@github.com/bundler/bundler-mismatch.git"] = "u:p"
+      Bundler.settings.temporary("https://u:p@github.com/bundler/bundler-mismatch.git" => "u:p")
       expect(subject).to receive(:git_retry).with(match(uri))
       subject.checkout
     end
 
     it "keeps original userinfo" do
-      Bundler.settings["github.com"] = "u:p"
+      Bundler.settings.temporary("github.com" => "u:p")
       original = "https://orig:info@github.com/bundler/bundler.git"
       subject = described_class.new(Pathname("path"), original, "HEAD")
       expect(subject).to receive(:git_retry).with(match(original))
diff --git a/spec/bundler/source/rubygems/remote_spec.rb b/spec/bundler/source/rubygems/remote_spec.rb
index 539360d067a..1aa008f3bbd 100644
--- a/spec/bundler/source/rubygems/remote_spec.rb
+++ b/spec/bundler/source/rubygems/remote_spec.rb
@@ -22,7 +22,7 @@ def remote(uri)
       end
 
       it "applies configured credentials" do
-        Bundler.settings[uri_no_auth.to_s] = credentials
+        Bundler.settings.temporary(uri_no_auth.to_s => credentials)
         expect(remote(uri_no_auth).uri).to eq(uri_with_auth)
       end
     end
@@ -33,7 +33,7 @@ def remote(uri)
       end
 
       it "does not apply given credentials" do
-        Bundler.settings[uri_no_auth.to_s] = credentials
+        Bundler.settings.temporary(uri_no_auth.to_s => credentials)
         expect(remote(uri_no_auth).anonymized_uri).to eq(uri_no_auth)
       end
     end
@@ -44,7 +44,7 @@ def remote(uri)
       end
 
       it "only applies the given user" do
-        Bundler.settings[uri_no_auth.to_s] = credentials
+        Bundler.settings.temporary(uri_no_auth.to_s => credentials)
         expect(remote(uri_no_auth).cache_slug).to eq("gems.example.com.username.443.MD5HEX(gems.example.com.username.443./)")
       end
     end
@@ -57,7 +57,7 @@ def remote(uri)
       end
 
       it "does not apply configured credentials" do
-        Bundler.settings[uri_no_auth.to_s] = "other:stuff"
+        Bundler.settings.temporary(uri_no_auth.to_s => "other:stuff")
         expect(remote(uri_with_auth).uri).to eq(uri_with_auth)
       end
     end
@@ -68,7 +68,7 @@ def remote(uri)
       end
 
       it "does not apply given credentials" do
-        Bundler.settings[uri_no_auth.to_s] = "other:stuff"
+        Bundler.settings.temporary(uri_no_auth.to_s => "other:stuff")
         expect(remote(uri_with_auth).anonymized_uri).to eq(uri_no_auth)
       end
     end
@@ -79,7 +79,7 @@ def remote(uri)
       end
 
       it "does not apply given credentials" do
-        Bundler.settings[uri_with_auth.to_s] = credentials
+        Bundler.settings.temporary(uri_with_auth.to_s => credentials)
         expect(remote(uri_with_auth).cache_slug).to eq("gems.example.com.username.443.MD5HEX(gems.example.com.username.443./)")
       end
     end
@@ -106,7 +106,7 @@ def remote(uri)
     let(:mirror_uri_with_auth) { URI("https://username:password@rubygems-mirror.org/") }
     let(:mirror_uri_no_auth) { URI("https://rubygems-mirror.org/") }
 
-    before { Bundler.settings["mirror.https://rubygems.org/"] = mirror_uri_with_auth.to_s }
+    before { Bundler.settings.set_local("mirror.https://rubygems.org/", mirror_uri_with_auth.to_s) }
 
     specify "#uri returns the mirror URI with credentials" do
       expect(remote(uri).uri).to eq(mirror_uri_with_auth)
@@ -131,8 +131,8 @@ def remote(uri)
     let(:mirror_uri_no_auth) { URI("https://rubygems-mirror.org/") }
 
     before do
-      Bundler.settings["mirror.https://rubygems.org/"] = mirror_uri_no_auth.to_s
-      Bundler.settings[mirror_uri_no_auth.to_s] = credentials
+      Bundler.settings.temporary("mirror.https://rubygems.org/" => mirror_uri_no_auth.to_s)
+      Bundler.settings.temporary(mirror_uri_no_auth.to_s => credentials)
     end
 
     specify "#uri returns the mirror URI with credentials" do
diff --git a/spec/bundler/source_list_spec.rb b/spec/bundler/source_list_spec.rb
index 915b638a461..ce3353012c8 100644
--- a/spec/bundler/source_list_spec.rb
+++ b/spec/bundler/source_list_spec.rb
@@ -85,7 +85,7 @@
         end
 
         it "ignores git protocols on request" do
-          Bundler.settings["git.allow_insecure"] = true
+          Bundler.settings.temporary(:"git.allow_insecure" => true)
           expect(Bundler.ui).to_not receive(:warn).with(msg)
           source_list.add_git_source("uri" => "git://existing-git.org/path.git")
         end
diff --git a/spec/bundler/yaml_serializer_spec.rb b/spec/bundler/yaml_serializer_spec.rb
index abe8554f072..2970fb44ec7 100644
--- a/spec/bundler/yaml_serializer_spec.rb
+++ b/spec/bundler/yaml_serializer_spec.rb
@@ -156,6 +156,7 @@
         "a_joke" => {
           "my-stand" => "I can totally keep secrets",
           "but" => "The people I tell them to can't :P",
+          "wouldn't it be funny if this string were empty?" => "",
         },
         "more" => {
           "first" => [
diff --git a/spec/cache/git_spec.rb b/spec/cache/git_spec.rb
index b780b19376b..562fc881c0c 100644
--- a/spec/cache/git_spec.rb
+++ b/spec/cache/git_spec.rb
@@ -100,7 +100,7 @@
         gem "foo", :git => '#{lib_path("foo-1.0")}'
       G
 
-      bundle "#{cmd} --all"
+      bundle! cmd, forgotten_command_line_options([:all, :cache_all] => true)
 
       update_git "foo" do |s|
         s.write "lib/foo.rb", "puts :CACHE"
@@ -187,8 +187,8 @@
         gem "foo", :git => '#{lib_path("foo-1.0")}'
       G
 
-      bundle "#{cmd} --all"
-      bundle "#{cmd}"
+      bundle cmd, forgotten_command_line_options([:all, :cache_all] => true)
+      bundle cmd
 
       expect(out).not_to include("Your Gemfile contains path and git dependencies.")
     end
@@ -204,7 +204,7 @@
       install_gemfile <<-G
         gem "foo", :git => '#{lib_path("foo-1.0")}'
       G
-      bundle "#{cmd} --all"
+      bundle cmd, forgotten_command_line_options([:all, :cache_all] => true)
 
       ref = git.ref_for("master", 11)
       gemspec = bundled_app("vendor/cache/foo-1.0-#{ref}/foo.gemspec").read
diff --git a/spec/cache/path_spec.rb b/spec/cache/path_spec.rb
index 3bf67204ce5..327d0abf601 100644
--- a/spec/cache/path_spec.rb
+++ b/spec/cache/path_spec.rb
@@ -9,7 +9,7 @@
         gem "foo", :path => '#{bundled_app("lib/foo")}'
       G
 
-      bundle "#{cmd} --all"
+      bundle cmd, forgotten_command_line_options([:all, :cache_all] => true)
       expect(bundled_app("vendor/cache/foo-1.0")).not_to exist
       expect(the_bundle).to include_gems "foo 1.0"
     end
@@ -21,7 +21,7 @@
         gem "foo", :path => '#{lib_path("foo-1.0")}'
       G
 
-      bundle "#{cmd} --all"
+      bundle cmd, forgotten_command_line_options([:all, :cache_all] => true)
       expect(bundled_app("vendor/cache/foo-1.0")).to exist
       expect(bundled_app("vendor/cache/foo-1.0/.bundlecache")).to be_file
 
@@ -39,7 +39,7 @@
         gem "#{libname}", :path => '#{libpath}'
       G
 
-      bundle "#{cmd} --all"
+      bundle cmd, forgotten_command_line_options([:all, :cache_all] => true)
       expect(bundled_app("vendor/cache/#{libname}")).to exist
       expect(bundled_app("vendor/cache/#{libname}/.bundlecache")).to be_file
 
@@ -54,13 +54,13 @@
         gem "foo", :path => '#{lib_path("foo-1.0")}'
       G
 
-      bundle "#{cmd} --all"
+      bundle cmd, forgotten_command_line_options([:all, :cache_all] => true)
 
       build_lib "foo" do |s|
         s.write "lib/foo.rb", "puts :CACHE"
       end
 
-      bundle "#{cmd} --all"
+      bundle cmd, forgotten_command_line_options([:all, :cache_all] => true)
 
       expect(bundled_app("vendor/cache/foo-1.0")).to exist
       FileUtils.rm_rf lib_path("foo-1.0")
@@ -76,13 +76,13 @@
         gem "foo", :path => '#{lib_path("foo-1.0")}'
       G
 
-      bundle "#{cmd} --all"
+      bundle cmd, forgotten_command_line_options([:all, :cache_all] => true)
 
       install_gemfile <<-G
         gem "bar", :path => '#{lib_path("bar-1.0")}'
       G
 
-      bundle "#{cmd} --all"
+      bundle cmd, forgotten_command_line_options([:all, :cache_all] => true)
       expect(bundled_app("vendor/cache/bar-1.0")).not_to exist
     end
 
@@ -105,7 +105,7 @@
         gem "foo", :path => '#{lib_path("foo-1.0")}'
       G
 
-      bundle "#{cmd} --all"
+      bundle cmd, forgotten_command_line_options([:all, :cache_all] => true)
       build_lib "bar"
 
       install_gemfile <<-G
@@ -124,7 +124,7 @@
         gem "foo", :path => '#{lib_path("foo-1.0")}'
       G
 
-      bundle "#{cmd} --all"
+      bundle cmd, forgotten_command_line_options([:all, :cache_all] => true)
       build_lib "baz"
 
       gemfile <<-G
diff --git a/spec/commands/binstubs_spec.rb b/spec/commands/binstubs_spec.rb
index 430dbef314e..89fc3866f7a 100644
--- a/spec/commands/binstubs_spec.rb
+++ b/spec/commands/binstubs_spec.rb
@@ -143,15 +143,15 @@
       expect(bundled_app("exec/rackup")).to exist
     end
 
-    it "setting is saved for bundle install" do
+    it "setting is saved for bundle install", :bundler => "< 2" do
       install_gemfile <<-G
         source "file://#{gem_repo1}"
         gem "rack"
         gem "rails"
       G
 
-      bundle "binstubs rack --path exec"
-      bundle :install
+      bundle! "binstubs rack", forgotten_command_line_options([:path, :bin] => "exec")
+      bundle! :install
 
       expect(bundled_app("exec/rails")).to exist
     end
@@ -159,15 +159,16 @@
 
   context "after installing with --standalone" do
     before do
-      install_gemfile <<-G
+      install_gemfile! <<-G
         source "file://#{gem_repo1}"
         gem "rack"
       G
-      bundle "install --standalone"
+      forgotten_command_line_options(:path => "bundle")
+      bundle! "install", :standalone => true
     end
 
     it "includes the standalone path" do
-      bundle "binstubs rack --standalone"
+      bundle! "binstubs rack", :standalone => true
       standalone_line = File.read(bundled_app("bin/rackup")).each_line.find {|line| line.include? "$:.unshift" }.strip
       expect(standalone_line).to eq %($:.unshift File.expand_path "../../bundle", path.realpath)
     end
diff --git a/spec/commands/check_spec.rb b/spec/commands/check_spec.rb
index b16d86e6b6d..3c25a8e8c8e 100644
--- a/spec/commands/check_spec.rb
+++ b/spec/commands/check_spec.rb
@@ -92,7 +92,7 @@
     expect(out).to include("Bundler can't satisfy your Gemfile's dependencies.")
   end
 
-  it "remembers --without option from install" do
+  it "remembers --without option from install", :bundler => "< 2" do
     gemfile <<-G
       source "file://#{gem_repo1}"
       group :foo do
@@ -100,9 +100,21 @@
       end
     G
 
-    bundle "install --without foo"
-    bundle "check"
-    expect(exitstatus).to eq(0) if exitstatus
+    bundle! "install --without foo"
+    bundle! "check"
+    expect(out).to include("The Gemfile's dependencies are satisfied")
+  end
+
+  it "uses the without setting" do
+    bundle! "config without foo"
+    install_gemfile! <<-G
+      source "file://#{gem_repo1}"
+      group :foo do
+        gem "rack"
+      end
+    G
+
+    bundle! "check"
     expect(out).to include("The Gemfile's dependencies are satisfied")
   end
 
@@ -112,7 +124,7 @@
       gem "rack", :group => :foo
     G
 
-    bundle "install --without foo"
+    bundle :install, forgotten_command_line_options(:without => "foo")
 
     gemfile <<-G
       source "file://#{gem_repo1}"
@@ -219,15 +231,14 @@
       gem "foo"
     G
 
-    bundle! "config deployment true"
-    bundle! :install
+    bundle! "install", forgotten_command_line_options(:deployment => true)
     FileUtils.rm(bundled_app("Gemfile.lock"))
 
     bundle :check
     expect(last_command).to be_failure
   end
 
-  context "--path" do
+  context "--path", :bundler => "< 2" do
     before do
       gemfile <<-G
         source "file://#{gem_repo1}"
@@ -239,15 +250,13 @@
     end
 
     it "returns success" do
-      bundle "check --path vendor/bundle"
-      expect(exitstatus).to eq(0) if exitstatus
+      bundle! "check --path vendor/bundle"
       expect(out).to include("The Gemfile's dependencies are satisfied")
     end
 
-    it "should write to .bundle/config" do
+    it "should write to .bundle/config", :bundler => "< 2" do
       bundle "check --path vendor/bundle"
-      bundle "check"
-      expect(exitstatus).to eq(0) if exitstatus
+      bundle! "check"
     end
   end
 
diff --git a/spec/commands/clean_spec.rb b/spec/commands/clean_spec.rb
index 3f3dc8565d7..e1febcbd4ea 100644
--- a/spec/commands/clean_spec.rb
+++ b/spec/commands/clean_spec.rb
@@ -25,16 +25,16 @@ def should_not_have_gems(*gems)
       gem "foo"
     G
 
-    bundle "install --path vendor/bundle --no-clean"
+    bundle! "install", forgotten_command_line_options(:path => "vendor/bundle", :clean => false)
 
     gemfile <<-G
       source "file://#{gem_repo1}"
 
       gem "thin"
     G
-    bundle "install"
+    bundle! "install"
 
-    bundle :clean
+    bundle! :clean
 
     expect(out).to include("Removing foo (1.0)")
 
@@ -52,7 +52,7 @@ def should_not_have_gems(*gems)
       gem "foo"
     G
 
-    bundle "install --path vendor/bundle --no-clean"
+    bundle "install", forgotten_command_line_options(:path => "vendor/bundle", :clean => false)
 
     gemfile <<-G
       source "file://#{gem_repo1}"
@@ -80,7 +80,7 @@ def should_not_have_gems(*gems)
       gem "foo"
     G
 
-    bundle! "install --path vendor/bundle --no-clean"
+    bundle! "install", forgotten_command_line_options(:path => "vendor/bundle", :clean => false)
 
     gemfile <<-G
       source "file://#{gem_repo1}"
@@ -111,8 +111,8 @@ def should_not_have_gems(*gems)
       end
     G
 
-    bundle "install --path vendor/bundle"
-    bundle "install --without test_group"
+    bundle "install", forgotten_command_line_options(:path => "vendor/bundle")
+    bundle "install", forgotten_command_line_options(:without => "test_group")
     bundle :clean
 
     expect(out).to include("Removing rack (1.0.0)")
@@ -137,7 +137,7 @@ def should_not_have_gems(*gems)
       end
     G
 
-    bundle "install --path vendor/bundle"
+    bundle "install", forgotten_command_line_options(:path => "vendor/bundle")
 
     bundle :clean
 
@@ -159,7 +159,7 @@ def should_not_have_gems(*gems)
       end
     G
 
-    bundle "install --path vendor/bundle"
+    bundle "install", forgotten_command_line_options(:path => "vendor/bundle")
 
     gemfile <<-G
       source "file://#{gem_repo1}"
@@ -195,7 +195,7 @@ def should_not_have_gems(*gems)
       end
     G
 
-    bundle! "install --path vendor/bundle"
+    bundle! "install", forgotten_command_line_options(:path => "vendor/bundle")
 
     update_git "foo", :path => lib_path("foo-bar")
     revision2 = revision_for(lib_path("foo-bar"))
@@ -225,7 +225,7 @@ def should_not_have_gems(*gems)
       gem "activesupport", :git => "#{lib_path("rails")}", :ref => '#{revision}'
     G
 
-    bundle "install --path vendor/bundle"
+    bundle "install", forgotten_command_line_options(:path => "vendor/bundle")
     bundle :clean
     expect(out).to include("")
 
@@ -247,7 +247,7 @@ def should_not_have_gems(*gems)
         end
       end
     G
-    bundle "install --path vendor/bundle --without test"
+    bundle "install", forgotten_command_line_options(:path => "vendor/bundle", :without => "test")
 
     bundle :clean
 
@@ -268,7 +268,7 @@ def should_not_have_gems(*gems)
       end
     G
 
-    bundle "install --path vendor/bundle --without development"
+    bundle "install", forgotten_command_line_options(:path => "vendor/bundle", :without => "development")
 
     bundle :clean
     expect(exitstatus).to eq(0) if exitstatus
@@ -283,7 +283,7 @@ def should_not_have_gems(*gems)
 
     bundle :clean
 
-    expect(exitstatus).to eq(1) if exitstatus
+    expect(exitstatus).to eq(15) if exitstatus
     expect(out).to include("--force")
   end
 
@@ -296,7 +296,7 @@ def should_not_have_gems(*gems)
       gem "foo"
     G
 
-    bundle "install --path vendor/bundle"
+    bundle "install", forgotten_command_line_options(:path => "vendor/bundle")
 
     gemfile <<-G
       source "file://#{gem_repo1}"
@@ -338,14 +338,14 @@ def should_not_have_gems(*gems)
     expect(out).to include("thin (1.0)")
   end
 
-  it "--clean should override the bundle setting on install" do
+  it "--clean should override the bundle setting on install", :bundler => "< 2" do
     gemfile <<-G
       source "file://#{gem_repo1}"
 
       gem "thin"
       gem "rack"
     G
-    bundle "install --path vendor/bundle --clean"
+    bundle "install", forgotten_command_line_options(:path => "vendor/bundle", :clean => true)
 
     gemfile <<-G
       source "file://#{gem_repo1}"
@@ -358,7 +358,7 @@ def should_not_have_gems(*gems)
     should_not_have_gems "thin-1.0"
   end
 
-  it "--clean should override the bundle setting on update" do
+  it "--clean should override the bundle setting on update", :bundler => "< 2" do
     build_repo2
 
     gemfile <<-G
@@ -366,7 +366,7 @@ def should_not_have_gems(*gems)
 
       gem "foo"
     G
-    bundle! "install --path vendor/bundle --clean"
+    bundle! "install", forgotten_command_line_options(:path => "vendor/bundle", :clean => true)
 
     update_repo2 do
       build_gem "foo", "1.0.1"
@@ -385,7 +385,7 @@ def should_not_have_gems(*gems)
       gem "thin"
       gem "rack"
     G
-    bundle "install --path vendor/bundle"
+    bundle "install", forgotten_command_line_options(:path => "vendor/bundle")
 
     gemfile <<-G
       source "file://#{gem_repo1}"
@@ -405,7 +405,7 @@ def should_not_have_gems(*gems)
 
       gem "foo"
     G
-    bundle! "install --path vendor/bundle"
+    bundle! "install", forgotten_command_line_options(:path => "vendor/bundle")
 
     update_repo2 do
       build_gem "foo", "1.0.1"
@@ -501,7 +501,7 @@ def should_not_have_gems(*gems)
       gem "foo", :git => "#{lib_path("foo-1.0")}"
     G
 
-    bundle "install --path vendor/bundle"
+    bundle "install", forgotten_command_line_options(:path => "vendor/bundle")
 
     # mimic 7 length git revisions in Gemfile.lock
     gemfile_lock = File.read(bundled_app("Gemfile.lock")).split("\n")
@@ -512,7 +512,7 @@ def should_not_have_gems(*gems)
       file.print gemfile_lock.join("\n")
     end
 
-    bundle "install --path vendor/bundle"
+    bundle "install", forgotten_command_line_options(:path => "vendor/bundle")
 
     bundle :clean
 
@@ -560,10 +560,8 @@ def should_not_have_gems(*gems)
       gem "bar", "1.0", :path => "#{relative_path}"
     G
 
-    bundle "install --path vendor/bundle"
-    bundle :clean
-
-    expect(exitstatus).to eq(0) if exitstatus
+    bundle "install", forgotten_command_line_options(:path => "vendor/bundle")
+    bundle! :clean
   end
 
   it "doesn't remove gems in dry-run mode with path set" do
@@ -574,7 +572,7 @@ def should_not_have_gems(*gems)
       gem "foo"
     G
 
-    bundle "install --path vendor/bundle --no-clean"
+    bundle "install", forgotten_command_line_options(:path => "vendor/bundle", :clean => false)
 
     gemfile <<-G
       source "file://#{gem_repo1}"
@@ -602,7 +600,7 @@ def should_not_have_gems(*gems)
       gem "foo"
     G
 
-    bundle "install --path vendor/bundle --no-clean"
+    bundle "install", forgotten_command_line_options(:path => "vendor/bundle", :clean => false)
 
     gemfile <<-G
       source "file://#{gem_repo1}"
@@ -632,7 +630,7 @@ def should_not_have_gems(*gems)
       gem "foo"
     G
 
-    bundle "install --path vendor/bundle --no-clean"
+    bundle "install", forgotten_command_line_options(:path => "vendor/bundle", :clean => false)
     bundle "config dry_run false"
 
     gemfile <<-G
@@ -662,7 +660,7 @@ def should_not_have_gems(*gems)
       gem "foo"
     G
 
-    bundle "install --path vendor/bundle --no-clean"
+    bundle "install", forgotten_command_line_options(:path => "vendor/bundle", :clean => false)
 
     gemfile <<-G
       source "file://#{gem_repo1}"
@@ -689,7 +687,7 @@ def should_not_have_gems(*gems)
       gem "very_simple_git_binary", :git => "#{lib_path("very_simple_git_binary-1.0")}", :ref => "#{revision}"
     G
 
-    bundle! "install --path vendor/bundle"
+    bundle! "install", forgotten_command_line_options(:path => "vendor/bundle")
     expect(vendored_gems("bundler/gems/extensions")).to exist
     expect(vendored_gems("bundler/gems/very_simple_git_binary-1.0-#{revision[0..11]}")).to exist
 
diff --git a/spec/commands/config_spec.rb b/spec/commands/config_spec.rb
index 4b9b27e0d55..9e493574650 100644
--- a/spec/commands/config_spec.rb
+++ b/spec/commands/config_spec.rb
@@ -45,7 +45,7 @@
   describe "BUNDLE_APP_CONFIG" do
     it "can be moved with an environment variable" do
       ENV["BUNDLE_APP_CONFIG"] = tmp("foo/bar").to_s
-      bundle "install --path vendor/bundle"
+      bundle "install", forgotten_command_line_options(:path => "vendor/bundle")
 
       expect(bundled_app(".bundle")).not_to exist
       expect(tmp("foo/bar/config")).to exist
@@ -57,7 +57,7 @@
       Dir.chdir bundled_app("omg")
 
       ENV["BUNDLE_APP_CONFIG"] = "../foo"
-      bundle "install --path vendor/bundle"
+      bundle "install", forgotten_command_line_options(:path => "vendor/bundle")
 
       expect(bundled_app(".bundle")).not_to exist
       expect(bundled_app("../foo/config")).to exist
diff --git a/spec/commands/exec_spec.rb b/spec/commands/exec_spec.rb
index c2e3b88fdd4..8acc00fc911 100644
--- a/spec/commands/exec_spec.rb
+++ b/spec/commands/exec_spec.rb
@@ -139,7 +139,7 @@
   end
 
   it "handles gems installed with --without" do
-    install_gemfile <<-G, :without => :middleware
+    install_gemfile <<-G, forgotten_command_line_options(:without => "middleware")
       source "file://#{gem_repo1}"
       gem "rack" # rack 0.9.1 and 1.0 exist
 
diff --git a/spec/commands/init_spec.rb b/spec/commands/init_spec.rb
index abcdd6ab92f..0441e62e13b 100644
--- a/spec/commands/init_spec.rb
+++ b/spec/commands/init_spec.rb
@@ -47,7 +47,7 @@
     end
   end
 
-  context "given --gemspec option" do
+  context "given --gemspec option", :bundler => "< 2" do
     let(:spec_file) { tmp.join("test.gemspec") }
 
     it "should generate from an existing gemspec" do
@@ -116,7 +116,7 @@
       end
     end
 
-    context "given --gemspec option" do
+    context "given --gemspec option", :bundler => "< 2" do
       let(:spec_file) { tmp.join("test.gemspec") }
 
       before do
diff --git a/spec/commands/install_spec.rb b/spec/commands/install_spec.rb
index 3858a45b829..fd825a374f0 100644
--- a/spec/commands/install_spec.rb
+++ b/spec/commands/install_spec.rb
@@ -261,21 +261,21 @@
       end
 
       it "works" do
-        bundle "install --path vendor"
+        bundle "install", forgotten_command_line_options(:path => "vendor")
         expect(the_bundle).to include_gems "rack 1.0"
       end
 
-      it "allows running bundle install --system without deleting foo" do
-        bundle "install --path vendor"
-        bundle "install --system"
+      it "allows running bundle install --system without deleting foo", :bundler => "< 2" do
+        bundle "install", forgotten_command_line_options(:path => "vendor")
+        bundle "install", forgotten_command_line_options(:system => true)
         FileUtils.rm_rf(bundled_app("vendor"))
         expect(the_bundle).to include_gems "rack 1.0"
       end
 
-      it "allows running bundle install --system after deleting foo" do
-        bundle "install --path vendor"
+      it "allows running bundle install --system after deleting foo", :bundler => "< 2" do
+        bundle "install", forgotten_command_line_options(:path => "vendor")
         FileUtils.rm_rf(bundled_app("vendor"))
-        bundle "install --system"
+        bundle "install", forgotten_command_line_options(:system => true)
         expect(the_bundle).to include_gems "rack 1.0"
       end
     end
@@ -486,7 +486,7 @@
     it "should display a proper message to explain the problem" do
       FileUtils.chmod(0o500, bundled_app("vendor"))
 
-      bundle :install, :path => "vendor"
+      bundle :install, forgotten_command_line_options(:path => "vendor")
       expect(out).to include(bundled_app("vendor").to_s)
       expect(out).to include("grant write permissions")
     end
diff --git a/spec/commands/outdated_spec.rb b/spec/commands/outdated_spec.rb
index 7e2a71e0674..c7964365a61 100644
--- a/spec/commands/outdated_spec.rb
+++ b/spec/commands/outdated_spec.rb
@@ -407,7 +407,7 @@ def test_group_option(group = nil, gems_list_size = 1)
 
   context "after bundle install --deployment", :bundler => "< 2" do
     before do
-      install_gemfile <<-G, :deployment => true
+      install_gemfile <<-G, forgotten_command_line_options(:deployment => true)
         source "file://#{gem_repo2}"
 
         gem "rack"
diff --git a/spec/commands/package_spec.rb b/spec/commands/package_spec.rb
index d2854f122f5..50d93be127d 100644
--- a/spec/commands/package_spec.rb
+++ b/spec/commands/package_spec.rb
@@ -141,14 +141,14 @@
     end
   end
 
-  context "with --path" do
+  context "with --path", :bundler => "< 2" do
     it "sets root directory for gems" do
       gemfile <<-D
         source "file://#{gem_repo1}"
         gem 'rack'
       D
 
-      bundle "package --path=#{bundled_app("test")}"
+      bundle! :package, forgotten_command_line_options(:path => bundled_app("test"))
 
       expect(the_bundle).to include_gems "rack 1.0.0"
       expect(bundled_app("test/vendor/cache/")).to exist
@@ -202,7 +202,7 @@
       bundle "install"
     end
 
-    subject { bundle "package --frozen" }
+    subject { bundle :package, forgotten_command_line_options(:frozen => true) }
 
     it "tries to install with frozen" do
       bundle! "config deployment true"
@@ -241,16 +241,16 @@
 
     it "does not hit the remote at all" do
       build_repo2
-      install_gemfile <<-G
+      install_gemfile! <<-G
         source "file://#{gem_repo2}"
         gem "rack"
       G
 
-      bundle :pack
+      bundle! :pack
       simulate_new_machine
       FileUtils.rm_rf gem_repo2
 
-      bundle "install --deployment"
+      bundle! :install, forgotten_command_line_options(:deployment => true, :path => "vendor/bundle")
       expect(the_bundle).to include_gems "rack 1.0.0"
     end
 
diff --git a/spec/commands/update_spec.rb b/spec/commands/update_spec.rb
index 49a2ceafd18..b7e0a173059 100644
--- a/spec/commands/update_spec.rb
+++ b/spec/commands/update_spec.rb
@@ -202,9 +202,9 @@
       bundle! "install --deployment"
       bundle "update", :all => bundle_update_requires_all?
 
+      expect(last_command).to be_failure
       expect(out).to match(/You are trying to install in deployment mode after changing.your Gemfile/m)
       expect(out).to match(/freeze \nby running `bundle install --no-deployment`./m)
-      expect(exitstatus).not_to eq(0) if exitstatus
     end
 
     it "should suggest different command when frozen is set globally", :bundler => "< 2" do
diff --git a/spec/install/binstubs_spec.rb b/spec/install/binstubs_spec.rb
index 12d5a99d4ef..e5acc84e6ab 100644
--- a/spec/install/binstubs_spec.rb
+++ b/spec/install/binstubs_spec.rb
@@ -20,7 +20,7 @@ def Gem.bindir; "/usr/bin"; end
     end
   end
 
-  describe "when multiple gems contain the same exe" do
+  describe "when multiple gems contain the same exe", :bundler => "< 2" do
     before do
       build_repo2 do
         build_gem "fake", "14" do |s|
diff --git a/spec/install/deploy_spec.rb b/spec/install/deploy_spec.rb
index e5a71609edc..11cf38a577c 100644
--- a/spec/install/deploy_spec.rb
+++ b/spec/install/deploy_spec.rb
@@ -8,44 +8,48 @@
     G
   end
 
-  it "fails without a lockfile and says that --deployment requires a lock" do
-    bundle "install --deployment"
-    expect(out).to include("The --deployment flag requires a Gemfile.lock")
-  end
+  context "with CLI flags", :bundler => "< 2" do
+    it "fails without a lockfile and says that --deployment requires a lock" do
+      bundle "install --deployment"
+      expect(out).to include("The --deployment flag requires a Gemfile.lock")
+    end
 
-  it "fails without a lockfile and says that --frozen requires a lock" do
-    bundle "install --frozen"
-    expect(out).to include("The --frozen flag requires a Gemfile.lock")
-  end
+    it "fails without a lockfile and says that --frozen requires a lock" do
+      bundle "install --frozen"
+      expect(out).to include("The --frozen flag requires a Gemfile.lock")
+    end
 
-  it "disallows --deployment --system" do
-    bundle "install --deployment --system"
-    expect(out).to include("You have specified both --deployment")
-    expect(out).to include("Please choose only one option")
-    expect(exitstatus).to eq(15) if exitstatus
-  end
+    it "disallows --deployment --system" do
+      bundle "install --deployment --system"
+      expect(out).to include("You have specified both --deployment")
+      expect(out).to include("Please choose only one option")
+      expect(exitstatus).to eq(15) if exitstatus
+    end
 
-  it "disallows --deployment --path --system" do
-    bundle "install --deployment --path . --system"
-    expect(out).to include("You have specified both --path")
-    expect(out).to include("as well as --system")
-    expect(out).to include("Please choose only one option")
-    expect(exitstatus).to eq(15) if exitstatus
-  end
+    it "disallows --deployment --path --system" do
+      bundle "install --deployment --path . --system"
+      expect(out).to include("You have specified both --path")
+      expect(out).to include("as well as --system")
+      expect(out).to include("Please choose only one option")
+      expect(exitstatus).to eq(15) if exitstatus
+    end
 
-  it "works after you try to deploy without a lock" do
-    bundle "install --deployment"
-    bundle :install
-    expect(exitstatus).to eq(0) if exitstatus
-    expect(the_bundle).to include_gems "rack 1.0"
+    it "works after you try to deploy without a lock" do
+      bundle "install --deployment"
+      bundle! :install
+      expect(the_bundle).to include_gems "rack 1.0"
+    end
   end
 
   it "still works if you are not in the app directory and specify --gemfile" do
     bundle "install"
-    Dir.chdir tmp
-    simulate_new_machine
-    bundle "install --gemfile #{tmp}/bundled_app/Gemfile --deployment"
-    Dir.chdir bundled_app
+    Dir.chdir tmp do
+      simulate_new_machine
+      bundle! :install,
+        forgotten_command_line_options(:gemfile => "#{tmp}/bundled_app/Gemfile",
+                                       :deployment => true,
+                                       :path => "vendor/bundle")
+    end
     expect(the_bundle).to include_gems "rack 1.0"
   end
 
@@ -57,15 +61,13 @@
       end
     G
     bundle :install
-    bundle "install --deployment --without test"
-    expect(exitstatus).to eq(0) if exitstatus
+    bundle! :install, forgotten_command_line_options(:deployment => true, :without => "test")
   end
 
   it "works when you bundle exec bundle" do
     bundle :install
     bundle "install --deployment"
-    bundle "exec bundle check"
-    expect(exitstatus).to eq(0) if exitstatus
+    bundle! "exec bundle check"
   end
 
   it "works when using path gems from the same path and the version is specified" do
@@ -77,7 +79,7 @@
     G
 
     bundle! :install
-    bundle! "install --deployment"
+    bundle! :install, forgotten_command_line_options(:deployment => true)
   end
 
   it "works when there are credentials in the source URL" do
@@ -87,9 +89,7 @@
       gem "rack-obama", ">= 1.0"
     G
 
-    bundle "install --deployment", :artifice => "endpoint_strict_basic_authentication"
-
-    expect(exitstatus).to eq(0) if exitstatus
+    bundle! :install, forgotten_command_line_options(:deployment => true).merge(:artifice => "endpoint_strict_basic_authentication")
   end
 
   it "works with sources given by a block" do
@@ -99,7 +99,7 @@
       end
     G
 
-    bundle! "install --deployment"
+    bundle! :install, forgotten_command_line_options(:deployment => true)
 
     expect(the_bundle).to include_gems "rack 1.0"
   end
@@ -109,14 +109,16 @@
       bundle "install"
     end
 
-    it "works with the --deployment flag if you didn't change anything" do
-      bundle "install --deployment"
-      expect(exitstatus).to eq(0) if exitstatus
+    it "works with the --deployment flag if you didn't change anything", :bundler => "< 2" do
+      bundle! "install --deployment"
     end
 
-    it "works with the --frozen flag if you didn't change anything" do
-      bundle "install --frozen"
-      expect(exitstatus).to eq(0) if exitstatus
+    it "works with the --frozen flag if you didn't change anything", :bundler => "< 2" do
+      bundle! "install --frozen"
+    end
+
+    it "works with BUNDLE_FROZEN if you didn't change anything" do
+      bundle! :install, :env => { "BUNDLE_FROZEN" => "true" }
     end
 
     it "explodes with the --deployment flag if you make a change and don't check in the lockfile" do
@@ -126,7 +128,7 @@
         gem "rack-obama"
       G
 
-      bundle "install --deployment"
+      bundle :install, forgotten_command_line_options(:deployment => true)
       expect(out).to include("deployment mode")
       expect(out).to include("You have added to the Gemfile")
       expect(out).to include("* rack-obama")
@@ -144,7 +146,7 @@
       expect(the_bundle).to include_gems "path_gem 1.0"
       FileUtils.rm_r lib_path("path_gem-1.0")
 
-      bundle! :install, :path => ".bundle", :without => "development", :deployment => true, :env => { :DEBUG => "1" }
+      bundle! :install, forgotten_command_line_options(:path => ".bundle", :without => "development", :deployment => true).merge(:env => { :DEBUG => "1" })
       run! "puts :WIN"
       expect(out).to eq("WIN")
     end
@@ -159,7 +161,7 @@
       expect(the_bundle).to include_gems "path_gem 1.0"
       FileUtils.rm_r lib_path("path_gem-1.0")
 
-      bundle :install, :path => ".bundle", :deployment => true
+      bundle :install, forgotten_command_line_options(:path => ".bundle", :deployment => true)
       expect(out).to include("The path `#{lib_path("path_gem-1.0")}` does not exist.")
     end
 
@@ -210,14 +212,14 @@
       expect(out).not_to include("* rack-obama")
     end
 
-    it "explodes with the --frozen flag if you make a change and don't check in the lockfile" do
+    it "explodes with the --frozen flag if you make a change and don't check in the lockfile", :bundler => "< 2" do
       gemfile <<-G
         source "file://#{gem_repo1}"
         gem "rack"
         gem "rack-obama", "1.1"
       G
 
-      bundle "install --frozen"
+      bundle :install, forgotten_command_line_options(:frozen => true)
       expect(out).to include("deployment mode")
       expect(out).to include("You have added to the Gemfile")
       expect(out).to include("* rack-obama (= 1.1)")
@@ -231,7 +233,7 @@
         gem "activesupport"
       G
 
-      bundle "install --deployment"
+      bundle :install, forgotten_command_line_options(:deployment => true)
       expect(out).to include("deployment mode")
       expect(out).to include("You have added to the Gemfile:\n* activesupport\n\n")
       expect(out).to include("You have deleted from the Gemfile:\n* rack")
@@ -244,7 +246,7 @@
         gem "rack", :git => "git://hubz.com"
       G
 
-      bundle "install --deployment"
+      bundle :install, forgotten_command_line_options(:deployment => true)
       expect(out).to include("deployment mode")
       expect(out).to include("You have added to the Gemfile:\n* source: git://hubz.com (at master)")
       expect(out).not_to include("You have changed in the Gemfile")
@@ -263,7 +265,7 @@
         gem "rack"
       G
 
-      bundle "install --deployment"
+      bundle :install, forgotten_command_line_options(:deployment => true)
       expect(out).to include("deployment mode")
       expect(out).to include("You have deleted from the Gemfile:\n* source: #{lib_path("rack-1.0")} (at master@#{revision_for(lib_path("rack-1.0"))[0..6]}")
       expect(out).not_to include("You have added to the Gemfile")
@@ -286,7 +288,7 @@
         gem "foo", :git => "#{lib_path("rack")}"
       G
 
-      bundle "install --deployment"
+      bundle :install, forgotten_command_line_options(:deployment => true)
       expect(out).to include("deployment mode")
       expect(out).to include("You have changed in the Gemfile:\n* rack from `no specified source` to `#{lib_path("rack")} (at master@#{revision_for(lib_path("rack"))[0..6]})`")
       expect(out).not_to include("You have added to the Gemfile")
@@ -334,7 +336,7 @@
       expect(out).to include("Updating files in vendor/cache")
 
       simulate_new_machine
-      bundle! "install --deployment --verbose"
+      bundle! "install --verbose", forgotten_command_line_options(:deployment => true)
       expect(out).not_to include("You are trying to install in deployment mode after changing your Gemfile")
       expect(out).not_to include("You have added to the Gemfile")
       expect(out).not_to include("You have deleted from the Gemfile")
diff --git a/spec/install/force_spec.rb b/spec/install/force_spec.rb
index 5592e62d684..52fa4f0d614 100644
--- a/spec/install/force_spec.rb
+++ b/spec/install/force_spec.rb
@@ -1,59 +1,61 @@
 # frozen_string_literal: true
 
 RSpec.describe "bundle install" do
-  describe "with --force" do
-    before :each do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-      G
-    end
+  %w[force redownload].each do |flag|
+    describe_opts = {}
+    describe_opts[:bundler] = "< 2" if flag == "force"
+    describe "with --#{flag}", describe_opts do
+      before :each do
+        gemfile <<-G
+          source "file://#{gem_repo1}"
+          gem "rack"
+        G
+      end
 
-    it "re-installs installed gems" do
-      rack_lib = default_bundle_path("gems/rack-1.0.0/lib/rack.rb")
+      it "re-installs installed gems" do
+        rack_lib = default_bundle_path("gems/rack-1.0.0/lib/rack.rb")
 
-      bundle "install"
-      rack_lib.open("w") {|f| f.write("blah blah blah") }
-      bundle "install --force"
+        bundle! :install
+        rack_lib.open("w") {|f| f.write("blah blah blah") }
+        bundle! :install, flag => true
 
-      expect(exitstatus).to eq(0) if exitstatus
-      expect(out).to include "Installing rack 1.0.0"
-      expect(rack_lib.open(&:read)).to eq("RACK = '1.0.0'\n")
-      expect(the_bundle).to include_gems "rack 1.0.0"
-    end
+        expect(out).to include "Installing rack 1.0.0"
+        expect(rack_lib.open(&:read)).to eq("RACK = '1.0.0'\n")
+        expect(the_bundle).to include_gems "rack 1.0.0"
+      end
 
-    it "works on first bundle install" do
-      bundle "install --force"
+      it "works on first bundle install" do
+        bundle! :install, flag => true
 
-      expect(exitstatus).to eq(0) if exitstatus
-      expect(out).to include "Installing rack 1.0.0"
-      expect(the_bundle).to include_gems "rack 1.0.0"
-    end
+        expect(out).to include "Installing rack 1.0.0"
+        expect(the_bundle).to include_gems "rack 1.0.0"
+      end
 
-    context "with a git gem" do
-      let!(:ref) { build_git("foo", "1.0").ref_for("HEAD", 11) }
+      context "with a git gem" do
+        let!(:ref) { build_git("foo", "1.0").ref_for("HEAD", 11) }
 
-      before do
-        gemfile <<-G
-          gem "foo", :git => "#{lib_path("foo-1.0")}"
-        G
-      end
+        before do
+          gemfile <<-G
+            gem "foo", :git => "#{lib_path("foo-1.0")}"
+          G
+        end
 
-      it "re-installs installed gems" do
-        foo_lib = default_bundle_path("bundler/gems/foo-1.0-#{ref}/lib/foo.rb")
+        it "re-installs installed gems" do
+          foo_lib = default_bundle_path("bundler/gems/foo-1.0-#{ref}/lib/foo.rb")
 
-        bundle! "install"
-        foo_lib.open("w") {|f| f.write("blah blah blah") }
-        bundle! "install --force"
+          bundle! :install
+          foo_lib.open("w") {|f| f.write("blah blah blah") }
+          bundle! :install, flag => true
 
-        expect(foo_lib.open(&:read)).to eq("FOO = '1.0'\n")
-        expect(the_bundle).to include_gems "foo 1.0"
-      end
+          expect(foo_lib.open(&:read)).to eq("FOO = '1.0'\n")
+          expect(the_bundle).to include_gems "foo 1.0"
+        end
 
-      it "works on first bundle install" do
-        bundle! "install --force"
+        it "works on first bundle install" do
+          bundle! :install, flag => true
 
-        expect(the_bundle).to include_gems "foo 1.0"
+          expect(the_bundle).to include_gems "foo 1.0"
+        end
       end
     end
   end
diff --git a/spec/install/gemfile/eval_gemfile_spec.rb b/spec/install/gemfile/eval_gemfile_spec.rb
index 242b746e019..380cfd85935 100644
--- a/spec/install/gemfile/eval_gemfile_spec.rb
+++ b/spec/install/gemfile/eval_gemfile_spec.rb
@@ -47,7 +47,7 @@
     # parsed lockfile and the evaluated gemfile.
     it "bundles with --deployment" do
       bundle! :install
-      bundle! "install --deployment"
+      bundle! :install, forgotten_command_line_options(:deployment => true)
     end
   end
 
diff --git a/spec/install/gemfile/gemspec_spec.rb b/spec/install/gemfile/gemspec_spec.rb
index e04dafb2fa6..2585f7106f9 100644
--- a/spec/install/gemfile/gemspec_spec.rb
+++ b/spec/install/gemfile/gemspec_spec.rb
@@ -272,7 +272,7 @@
           s.add_dependency "activesupport", ">= 1.0.1"
         end
 
-        bundle "install --deployment"
+        bundle :install, forgotten_command_line_options(:deployment => true)
 
         expect(out).to include("changed")
       end
@@ -651,7 +651,7 @@
     it "installs the ruby platform gemspec and skips dev deps with --without development" do
       simulate_platform "ruby"
 
-      install_gemfile! <<-G, :without => "development"
+      install_gemfile! <<-G, forgotten_command_line_options(:without => "development")
         source "file://#{gem_repo1}"
         gemspec :path => '#{tmp.join("foo")}', :name => 'foo'
       G
diff --git a/spec/install/gemfile/git_spec.rb b/spec/install/gemfile/git_spec.rb
index b3fc38ec248..71ef3c856f8 100644
--- a/spec/install/gemfile/git_spec.rb
+++ b/spec/install/gemfile/git_spec.rb
@@ -1022,8 +1022,7 @@
 
       simulate_new_machine
 
-      bundle "install --deployment"
-      expect(exitstatus).to eq(0) if exitstatus
+      bundle! :install, forgotten_command_line_options(:deployment => true)
     end
   end
 
diff --git a/spec/install/gemfile/groups_spec.rb b/spec/install/gemfile/groups_spec.rb
index b49b64d1f08..dc55f1d8d31 100644
--- a/spec/install/gemfile/groups_spec.rb
+++ b/spec/install/gemfile/groups_spec.rb
@@ -86,7 +86,7 @@
       end
 
       it "installs gems in the default group" do
-        bundle :install, :without => "emo"
+        bundle! :install, forgotten_command_line_options(:without => "emo")
         expect(the_bundle).to include_gems "rack 1.0.0", :groups => [:default]
       end
 
@@ -96,20 +96,20 @@
       end
 
       it "does not install gems from the previously excluded group" do
-        bundle :install, :without => "emo"
+        bundle :install, forgotten_command_line_options(:without => "emo")
         expect(the_bundle).not_to include_gems "activesupport 2.3.5"
         bundle :install
         expect(the_bundle).not_to include_gems "activesupport 2.3.5"
       end
 
       it "does not say it installed gems from the excluded group" do
-        bundle :install, :without => "emo"
+        bundle! :install, forgotten_command_line_options(:without => "emo")
         expect(out).not_to include("activesupport")
       end
 
       it "allows Bundler.setup for specific groups" do
-        bundle :install, :without => "emo"
-        run("require 'rack'; puts RACK", :default)
+        bundle :install, forgotten_command_line_options(:without => "emo")
+        run!("require 'rack'; puts RACK", :default)
         expect(out).to eq("1.0.0")
       end
 
@@ -122,15 +122,15 @@
           end
         G
 
-        bundle :install, :without => "emo"
+        bundle :install, forgotten_command_line_options(:without => "emo")
         expect(the_bundle).to include_gems "activesupport 2.3.2", :groups => [:default]
       end
 
       it "still works on a different machine and excludes gems" do
-        bundle :install, :without => "emo"
+        bundle :install, forgotten_command_line_options(:without => "emo")
 
         simulate_new_machine
-        bundle :install, :without => "emo"
+        bundle :install, forgotten_command_line_options(:without => "emo")
 
         expect(the_bundle).to include_gems "rack 1.0.0", :groups => [:default]
         expect(the_bundle).not_to include_gems "activesupport 2.3.5", :groups => [:default]
@@ -149,14 +149,14 @@
       end
 
       it "clears without when passed an empty list" do
-        bundle :install, :without => "emo"
+        bundle :install, forgotten_command_line_options(:without => "emo")
 
-        bundle 'install --without ""'
+        bundle :install, forgotten_command_line_options(:without => "")
         expect(the_bundle).to include_gems "activesupport 2.3.5"
       end
 
       it "doesn't clear without when nothing is passed" do
-        bundle :install, :without => "emo"
+        bundle :install, forgotten_command_line_options(:without => "emo")
 
         bundle :install
         expect(the_bundle).not_to include_gems "activesupport 2.3.5"
@@ -168,12 +168,12 @@
       end
 
       it "does install gems from the optional group when requested" do
-        bundle :install, :with => "debugging"
+        bundle :install, forgotten_command_line_options(:with => "debugging")
         expect(the_bundle).to include_gems "thin 1.0"
       end
 
       it "does install gems from the previously requested group" do
-        bundle :install, :with => "debugging"
+        bundle :install, forgotten_command_line_options(:with => "debugging")
         expect(the_bundle).to include_gems "thin 1.0"
         bundle :install
         expect(the_bundle).to include_gems "thin 1.0"
@@ -187,41 +187,55 @@
       end
 
       it "clears with when passed an empty list" do
-        bundle :install, :with => "debugging"
-        bundle 'install --with ""'
+        bundle :install, forgotten_command_line_options(:with => "debugging")
+        bundle :install, forgotten_command_line_options(:with => "")
         expect(the_bundle).not_to include_gems "thin 1.0"
       end
 
       it "does remove groups from without when passed at with" do
-        bundle :install, :without => "emo"
-        bundle :install, :with => "emo"
+        bundle :install, forgotten_command_line_options(:without => "emo")
+        bundle :install, forgotten_command_line_options(:with => "emo")
         expect(the_bundle).to include_gems "activesupport 2.3.5"
       end
 
-      it "does remove groups from with when passed at without" do
-        bundle :install, :with => "debugging"
-        bundle :install, :without => "debugging"
-        expect(the_bundle).not_to include_gems "thin 1.0"
+      it "does remove groups from with when passed at --without", :bundler => "< 2" do
+        bundle :install, forgotten_command_line_options(:with => "debugging")
+        bundle :install, forgotten_command_line_options(:without => "debugging")
+        expect(the_bundle).not_to include_gem "thin 1.0"
       end
 
-      it "errors out when passing a group to with and without" do
-        bundle :install, :with => "emo debugging", :without => "emo"
+      it "errors out when passing a group to with and without via CLI flags", :bundler => "< 2" do
+        bundle :install, forgotten_command_line_options(:with => "emo debugging", :without => "emo")
+        expect(last_command).to be_failure
         expect(out).to include("The offending groups are: emo")
       end
 
+      it "allows the BUNDLE_WITH setting to override BUNDLE_WITHOUT" do
+        bundle! "config --local with debugging"
+
+        bundle! :install
+        expect(the_bundle).to include_gem "thin 1.0"
+
+        bundle! "config --local without debugging"
+        expect(the_bundle).to include_gem "thin 1.0"
+
+        bundle! :install
+        expect(the_bundle).to include_gem "thin 1.0"
+      end
+
       it "can add and remove a group at the same time" do
-        bundle :install, :with => "debugging", :without => "emo"
+        bundle :install, forgotten_command_line_options(:with => "debugging", :without => "emo")
         expect(the_bundle).to include_gems "thin 1.0"
         expect(the_bundle).not_to include_gems "activesupport 2.3.5"
       end
 
       it "does have no effect when listing a not optional group in with" do
-        bundle :install, :with => "emo"
+        bundle :install, forgotten_command_line_options(:with => "emo")
         expect(the_bundle).to include_gems "activesupport 2.3.5"
       end
 
       it "does have no effect when listing an optional group in without" do
-        bundle :install, :without => "debugging"
+        bundle :install, forgotten_command_line_options(:without => "debugging")
         expect(the_bundle).not_to include_gems "thin 1.0"
       end
     end
@@ -238,12 +252,12 @@
       end
 
       it "installs gems in the default group" do
-        bundle :install, :without => "emo lolercoaster"
+        bundle! :install, forgotten_command_line_options(:without => "emo lolercoaster")
         expect(the_bundle).to include_gems "rack 1.0.0"
       end
 
       it "installs the gem if any of its groups are installed" do
-        bundle "install --without emo"
+        bundle! :install, forgotten_command_line_options(:without => "emo")
         expect(the_bundle).to include_gems "rack 1.0.0", "activesupport 2.3.5"
       end
 
@@ -264,22 +278,22 @@
         end
 
         it "installs the gem w/ option --without emo" do
-          bundle "install --without emo"
+          bundle :install, forgotten_command_line_options(:without => "emo")
           expect(the_bundle).to include_gems "activesupport 2.3.5"
         end
 
         it "installs the gem w/ option --without lolercoaster" do
-          bundle "install --without lolercoaster"
+          bundle :install, forgotten_command_line_options(:without => "lolercoaster")
           expect(the_bundle).to include_gems "activesupport 2.3.5"
         end
 
         it "does not install the gem w/ option --without emo lolercoaster" do
-          bundle "install --without emo lolercoaster"
+          bundle :install, forgotten_command_line_options(:without => "emo lolercoaster")
           expect(the_bundle).not_to include_gems "activesupport 2.3.5"
         end
 
         it "does not install the gem w/ option --without 'emo lolercoaster'" do
-          bundle "install --without 'emo lolercoaster'"
+          bundle :install, forgotten_command_line_options(:without => "'emo lolercoaster'")
           expect(the_bundle).not_to include_gems "activesupport 2.3.5"
         end
       end
@@ -299,12 +313,12 @@
       end
 
       it "installs gems in the default group" do
-        bundle :install, :without => "emo lolercoaster"
+        bundle! :install, forgotten_command_line_options(:without => "emo lolercoaster")
         expect(the_bundle).to include_gems "rack 1.0.0"
       end
 
       it "installs the gem if any of its groups are installed" do
-        bundle "install --without emo"
+        bundle! :install, forgotten_command_line_options(:without => "emo")
         expect(the_bundle).to include_gems "rack 1.0.0", "activesupport 2.3.5"
       end
     end
@@ -339,7 +353,7 @@
     before(:each) do
       build_repo2
       system_gems "rack-0.9.1" do
-        install_gemfile <<-G, :without => :rack
+        install_gemfile <<-G, forgotten_command_line_options(:without => "rack")
           source "file://#{gem_repo2}"
           gem "rack"
 
@@ -363,7 +377,7 @@
 
     it "does not hit the remote a second time" do
       FileUtils.rm_rf gem_repo2
-      bundle! "install --without rack", :verbose => true
+      bundle! :install, forgotten_command_line_options(:without => "rack").merge(:verbose => true)
       expect(last_command.stdboth).not_to match(/fetching/i)
     end
   end
diff --git a/spec/install/gemfile/path_spec.rb b/spec/install/gemfile/path_spec.rb
index 283c66dbfa2..f7789e7ea58 100644
--- a/spec/install/gemfile/path_spec.rb
+++ b/spec/install/gemfile/path_spec.rb
@@ -90,7 +90,7 @@
       gem 'foo', :path => File.expand_path("../foo-1.0", __FILE__)
     G
 
-    bundle "install --frozen"
+    bundle! :install, forgotten_command_line_options(:frozen => true)
     expect(exitstatus).to eq(0) if exitstatus
   end
 
diff --git a/spec/install/gemfile/platform_spec.rb b/spec/install/gemfile/platform_spec.rb
index 2317111e174..d14847daa9e 100644
--- a/spec/install/gemfile/platform_spec.rb
+++ b/spec/install/gemfile/platform_spec.rb
@@ -120,12 +120,12 @@
       gem "rack", "1.0.0"
     G
 
-    bundle "install --path vendor/bundle"
+    bundle! :install, forgotten_command_line_options(:path => "vendor/bundle")
 
     new_version = Gem::ConfigMap[:ruby_version] == "1.8" ? "1.9.1" : "1.8"
     FileUtils.mv(vendored_gems, bundled_app("vendor/bundle", Gem.ruby_engine, new_version))
 
-    bundle "install --path vendor/bundle"
+    bundle! :install
     expect(vendored_gems("gems/rack-1.0.0")).to exist
   end
 end
diff --git a/spec/install/gemfile/sources_spec.rb b/spec/install/gemfile/sources_spec.rb
index 7641a14254e..6afe8bda593 100644
--- a/spec/install/gemfile/sources_spec.rb
+++ b/spec/install/gemfile/sources_spec.rb
@@ -107,9 +107,8 @@
         expect(bundled_app("vendor/cache/rack-1.0.0.gem")).to exist
         expect(bundled_app("vendor/cache/rack-obama-1.0.gem")).to exist
 
-        bundle! "install --deployment"
+        bundle! :install, forgotten_command_line_options(:deployment => true)
 
-        expect(exitstatus).to eq(0) if exitstatus
         expect(the_bundle).to include_gems("rack-obama 1.0.0", "rack 1.0.0")
       end
     end
@@ -498,7 +497,7 @@
           rack
       L
 
-      bundle "install --path ../gems/system"
+      bundle! :install, forgotten_command_line_options(:path => "../gems/system")
 
       # 4. Then we add some new versions...
       update_repo4 do
@@ -517,8 +516,7 @@
       G
 
       # 6. Which should update foo to 0.2, but not the (locked) bar 0.1
-      expect(the_bundle).to include_gems("foo 0.2")
-      expect(the_bundle).to include_gems("bar 0.1")
+      expect(the_bundle).to include_gems("foo 0.2", "bar 0.1")
     end
   end
 
diff --git a/spec/install/gems/compact_index_spec.rb b/spec/install/gems/compact_index_spec.rb
index 0f1a2104336..6dadbd9fca4 100644
--- a/spec/install/gems/compact_index_spec.rb
+++ b/spec/install/gems/compact_index_spec.rb
@@ -80,7 +80,7 @@
     G
     bundle! :install, :artifice => "compact_index"
 
-    bundle "install --deployment", :artifice => "compact_index"
+    bundle! :install, forgotten_command_line_options(:deployment => true, :path => "vendor/bundle").merge(:artifice => "compact_index")
     expect(out).to include("Fetching gem metadata from #{source_uri}")
     expect(the_bundle).to include_gems "rack 1.0.0"
   end
@@ -129,9 +129,8 @@
     G
 
     bundle "install", :artifice => "compact_index"
-    bundle "install --deployment", :artifice => "compact_index"
+    bundle! :install, forgotten_command_line_options(:deployment => true).merge(:artifice => "compact_index")
 
-    expect(exitstatus).to eq(0) if exitstatus
     expect(the_bundle).to include_gems("foo 1.0")
   end
 
@@ -174,7 +173,7 @@
   end
 
   it "falls back when the user's home directory does not exist or is not writable" do
-    ENV["HOME"] = nil
+    ENV["HOME"] = tmp("missing_home").to_s
 
     gemfile <<-G
       source "#{source_uri}"
@@ -508,7 +507,7 @@ def require(*args)
     expect(the_bundle).to include_gems "rails 2.3.2"
   end
 
-  it "installs the binstubs" do
+  it "installs the binstubs", :bundler => "< 2" do
     gemfile <<-G
       source "#{source_uri}"
       gem "rack"
@@ -520,7 +519,7 @@ def require(*args)
     expect(out).to eq("1.0.0")
   end
 
-  it "installs the bins when using --path and uses autoclean" do
+  it "installs the bins when using --path and uses autoclean", :bundler => "< 2" do
     gemfile <<-G
       source "#{source_uri}"
       gem "rack"
@@ -531,7 +530,7 @@ def require(*args)
     expect(vendored_gems("bin/rackup")).to exist
   end
 
-  it "installs the bins when using --path and uses bundle clean" do
+  it "installs the bins when using --path and uses bundle clean", :bundler => "< 2" do
     gemfile <<-G
       source "#{source_uri}"
       gem "rack"
diff --git a/spec/install/gems/dependency_api_spec.rb b/spec/install/gems/dependency_api_spec.rb
index 14440652d6e..22c623ab40d 100644
--- a/spec/install/gems/dependency_api_spec.rb
+++ b/spec/install/gems/dependency_api_spec.rb
@@ -60,7 +60,7 @@
     G
     bundle :install, :artifice => "endpoint"
 
-    bundle "install --deployment", :artifice => "endpoint"
+    bundle! :install, forgotten_command_line_options(:deployment => true, :path => "vendor/bundle").merge(:artifice => "endpoint")
     expect(out).to include("Fetching gem metadata from #{source_uri}")
     expect(the_bundle).to include_gems "rack 1.0.0"
   end
@@ -109,9 +109,8 @@
     G
 
     bundle "install", :artifice => "endpoint"
-    bundle "install --deployment", :artifice => "endpoint"
+    bundle! :install, forgotten_command_line_options(:deployment => true).merge(:artifice => "endpoint")
 
-    expect(exitstatus).to eq(0) if exitstatus
     expect(the_bundle).to include_gems("foo 1.0")
   end
 
@@ -497,7 +496,7 @@ def require(*args)
     expect(the_bundle).to include_gems "rails 2.3.2"
   end
 
-  it "installs the binstubs" do
+  it "installs the binstubs", :bundler => "< 2" do
     gemfile <<-G
       source "#{source_uri}"
       gem "rack"
@@ -509,7 +508,7 @@ def require(*args)
     expect(out).to eq("1.0.0")
   end
 
-  it "installs the bins when using --path and uses autoclean" do
+  it "installs the bins when using --path and uses autoclean", :bundler => "< 2" do
     gemfile <<-G
       source "#{source_uri}"
       gem "rack"
@@ -520,7 +519,7 @@ def require(*args)
     expect(vendored_gems("bin/rackup")).to exist
   end
 
-  it "installs the bins when using --path and uses bundle clean" do
+  it "installs the bins when using --path and uses bundle clean", :bundler => "< 2" do
     gemfile <<-G
       source "#{source_uri}"
       gem "rack"
diff --git a/spec/install/gems/standalone_spec.rb b/spec/install/gems/standalone_spec.rb
index 88992723934..431854e6d53 100644
--- a/spec/install/gems/standalone_spec.rb
+++ b/spec/install/gems/standalone_spec.rb
@@ -50,10 +50,11 @@
 
   describe "with simple gems" do
     before do
-      install_gemfile <<-G, :standalone => true
+      gemfile <<-G
         source "file://#{gem_repo1}"
         gem "rails"
       G
+      bundle! :install, forgotten_command_line_options(:path => "bundle").merge(:standalone => true)
     end
 
     let(:expected_gems) do
@@ -68,7 +69,7 @@
 
   describe "with gems with native extension" do
     before do
-      install_gemfile <<-G, :standalone => true
+      install_gemfile <<-G, forgotten_command_line_options(:path => "bundle").merge(:standalone => true)
         source "file://#{gem_repo1}"
         gem "very_simple_binary"
       G
@@ -100,7 +101,7 @@
           end
         G
       end
-      install_gemfile <<-G, :standalone => true
+      install_gemfile <<-G, forgotten_command_line_options(:path => "bundle").merge(:standalone => true)
         gem "bar", :git => "#{lib_path("bar-1.0")}"
       G
     end
@@ -115,11 +116,12 @@
     before do
       build_git "devise", "1.0"
 
-      install_gemfile <<-G, :standalone => true
+      gemfile <<-G
         source "file://#{gem_repo1}"
         gem "rails"
         gem "devise", :git => "#{lib_path("devise-1.0")}"
       G
+      bundle! :install, forgotten_command_line_options(:path => "bundle").merge(:standalone => true)
     end
 
     let(:expected_gems) do
@@ -137,7 +139,7 @@
     before do
       build_git "devise", "1.0"
 
-      install_gemfile <<-G, :standalone => true
+      gemfile <<-G
         source "file://#{gem_repo1}"
         gem "rails"
 
@@ -146,6 +148,7 @@
           gem "rack-test"
         end
       G
+      bundle! :install, forgotten_command_line_options(:path => "bundle").merge(:standalone => true)
     end
 
     let(:expected_gems) do
@@ -158,7 +161,7 @@
     include_examples "common functionality"
 
     it "allows creating a standalone file with limited groups" do
-      bundle "install --standalone default"
+      bundle! "install", forgotten_command_line_options(:path => "bundle").merge(:standalone => "default")
 
       Dir.chdir(bundled_app) do
         load_error_ruby <<-RUBY, "spec", :no_lib => true
@@ -176,7 +179,7 @@
     end
 
     it "allows --without to limit the groups used in a standalone" do
-      bundle "install --standalone --without test"
+      bundle! :install, forgotten_command_line_options(:path => "bundle", :without => "test").merge(:standalone => true)
 
       Dir.chdir(bundled_app) do
         load_error_ruby <<-RUBY, "spec", :no_lib => true
@@ -194,7 +197,7 @@
     end
 
     it "allows --path to change the location of the standalone bundle" do
-      bundle "install --standalone --path path/to/bundle"
+      bundle! "install", forgotten_command_line_options(:path => "path/to/bundle").merge(:standalone => true)
 
       Dir.chdir(bundled_app) do
         ruby <<-RUBY, :no_lib => true
@@ -210,8 +213,8 @@
     end
 
     it "allows remembered --without to limit the groups used in a standalone" do
-      bundle "install --without test"
-      bundle "install --standalone"
+      bundle! :install, forgotten_command_line_options(:without => "test")
+      bundle! :install, forgotten_command_line_options(:path => "bundle").merge(:standalone => true)
 
       Dir.chdir(bundled_app) do
         load_error_ruby <<-RUBY, "spec", :no_lib => true
@@ -238,7 +241,7 @@
           source "#{source_uri}"
           gem "rails"
         G
-        bundle "install --standalone", :artifice => "endpoint"
+        bundle! :install, forgotten_command_line_options(:path => "bundle").merge(:standalone => true, :artifice => "endpoint")
       end
 
       let(:expected_gems) do
@@ -252,12 +255,13 @@
     end
   end
 
-  describe "with --binstubs" do
+  describe "with --binstubs", :bundler => "< 2" do
     before do
-      install_gemfile <<-G, :standalone => true, :binstubs => true
+      gemfile <<-G
         source "file://#{gem_repo1}"
         gem "rails"
       G
+      bundle! :install, forgotten_command_line_options(:path => "bundle").merge(:standalone => true, :binstubs => true)
     end
 
     let(:expected_gems) do
diff --git a/spec/install/gems/sudo_spec.rb b/spec/install/gems/sudo_spec.rb
index f2dce52c788..afcc33cc74d 100644
--- a/spec/install/gems/sudo_spec.rb
+++ b/spec/install/gems/sudo_spec.rb
@@ -161,16 +161,9 @@
       end
     end
 
-    context "when silence_root_warning is passed as an option" do
-      it "skips the warning" do
-        bundle :install, :sudo => true, :silence_root_warning => true
-        expect(out).to_not include(warning)
-      end
-    end
-
     context "when silence_root_warning = false" do
       it "warns against that" do
-        bundle :install, :sudo => true, :silence_root_warning => false
+        bundle :install, :sudo => true, :env => { "BUNDLE_SILENCE_ROOT_WARNING" => "false" }
         expect(out).to include(warning)
       end
     end
diff --git a/spec/install/git_spec.rb b/spec/install/git_spec.rb
index 85523b350e9..6ae718c2a40 100644
--- a/spec/install/git_spec.rb
+++ b/spec/install/git_spec.rb
@@ -57,7 +57,7 @@
           foo!
       L
 
-      bundle! "install --path=vendor/bundle --without development"
+      bundle! :install, forgotten_command_line_options(:path => "vendor/bundle", :without => "development")
 
       expect(out).to include("Bundle complete!")
     end
diff --git a/spec/install/path_spec.rb b/spec/install/path_spec.rb
index 206b59c26e7..f3e17845e3f 100644
--- a/spec/install/path_spec.rb
+++ b/spec/install/path_spec.rb
@@ -13,8 +13,8 @@
       G
     end
 
-    it "does not use available system gems with bundle --path vendor/bundle" do
-      bundle "install --path vendor/bundle"
+    it "does not use available system gems with bundle --path vendor/bundle", :bundler => "< 2" do
+      bundle! :install, forgotten_command_line_options(:path => "vendor/bundle")
       expect(the_bundle).to include_gems "rack 1.0.0"
     end
 
@@ -23,7 +23,7 @@
       dir.mkpath
 
       Dir.chdir(dir) do
-        bundle "install --path vendor/bundle"
+        bundle! :install, forgotten_command_line_options(:path => "vendor/bundle")
         expect(out).to include("installed into ./vendor/bundle")
       end
 
@@ -31,17 +31,17 @@
     end
 
     it "prints a warning to let the user know what has happened with bundle --path vendor/bundle" do
-      bundle "install --path vendor/bundle"
+      bundle! :install, forgotten_command_line_options(:path => "vendor/bundle")
       expect(out).to include("gems are installed into ./vendor")
     end
 
-    it "disallows --path vendor/bundle --system" do
+    it "disallows --path vendor/bundle --system", :bundler => "< 2" do
       bundle "install --path vendor/bundle --system"
       expect(out).to include("Please choose only one option.")
       expect(exitstatus).to eq(15) if exitstatus
     end
 
-    it "remembers to disable system gems after the first time with bundle --path vendor/bundle" do
+    it "remembers to disable system gems after the first time with bundle --path vendor/bundle", :bundler => "< 2" do
       bundle "install --path vendor/bundle"
       FileUtils.rm_rf bundled_app("vendor")
       bundle "install"
@@ -74,7 +74,7 @@ def set_bundle_path(type, location)
     [:env, :global].each do |type|
       it "installs gems to a path if one is specified" do
         set_bundle_path(type, bundled_app("vendor2").to_s)
-        bundle "install --path vendor/bundle"
+        bundle! :install, forgotten_command_line_options(:path => "vendor/bundle")
 
         expect(vendored_gems("gems/rack-1.0.0")).to be_directory
         expect(bundled_app("vendor2")).not_to be_directory
@@ -113,7 +113,7 @@ def set_bundle_path(type, location)
     end
 
     it "sets BUNDLE_PATH as the first argument to bundle install" do
-      bundle "install --path ./vendor/bundle"
+      bundle! :install, forgotten_command_line_options(:path => "./vendor/bundle")
 
       expect(vendored_gems("gems/rack-1.0.0")).to be_directory
       expect(the_bundle).to include_gems "rack 1.0.0"
@@ -122,7 +122,7 @@ def set_bundle_path(type, location)
     it "disables system gems when passing a path to install" do
       # This is so that vendored gems can be distributed to others
       build_gem "rack", "1.1.0", :to_system => true
-      bundle "install --path ./vendor/bundle"
+      bundle! :install, forgotten_command_line_options(:path => "./vendor/bundle")
 
       expect(vendored_gems("gems/rack-1.0.0")).to be_directory
       expect(the_bundle).to include_gems "rack 1.0.0"
@@ -138,7 +138,7 @@ def set_bundle_path(type, location)
         gem "very_simple_binary"
       G
 
-      bundle "install --path ./vendor/bundle"
+      bundle! :install, forgotten_command_line_options(:path => "./vendor/bundle")
 
       expect(vendored_gems("gems/very_simple_binary-1.0")).to be_directory
       expect(vendored_gems("extensions")).to be_directory
@@ -149,7 +149,7 @@ def set_bundle_path(type, location)
       run "require 'very_simple_binary_c'"
       expect(err).to include("Bundler::GemNotFound")
 
-      bundle "install --path ./vendor/bundle"
+      bundle :install, forgotten_command_line_options(:path => "./vendor/bundle")
 
       expect(vendored_gems("gems/very_simple_binary-1.0")).to be_directory
       expect(vendored_gems("extensions")).to be_directory
@@ -170,7 +170,7 @@ def set_bundle_path(type, location)
         gem "rack"
       G
 
-      bundle "install --path bundle"
+      bundle :install, forgotten_command_line_options(:path => "bundle")
       expect(out).to match(/file already exists/)
     end
   end
diff --git a/spec/install/post_bundle_message_spec.rb b/spec/install/post_bundle_message_spec.rb
index bc700b5c4ba..248ef2166a3 100644
--- a/spec/install/post_bundle_message_spec.rb
+++ b/spec/install/post_bundle_message_spec.rb
@@ -29,7 +29,7 @@
     end
 
     it "with --without one group" do
-      bundle "install --without emo"
+      bundle! :install, forgotten_command_line_options(:without => "emo")
       expect(out).to include(bundle_show_message)
       expect(out).to include("Gems in the group emo were not installed")
       expect(out).to include(bundle_complete_message)
@@ -37,7 +37,7 @@
     end
 
     it "with --without two groups" do
-      bundle "install --without emo test"
+      bundle! :install, forgotten_command_line_options(:without => "emo test")
       expect(out).to include(bundle_show_message)
       expect(out).to include("Gems in the groups emo and test were not installed")
       expect(out).to include(bundle_complete_message)
@@ -45,7 +45,7 @@
     end
 
     it "with --without more groups" do
-      bundle "install --without emo obama test"
+      bundle! :install, forgotten_command_line_options(:without => "emo obama test")
       expect(out).to include(bundle_show_message)
       expect(out).to include("Gems in the groups emo, obama and test were not installed")
       expect(out).to include(bundle_complete_message)
@@ -54,43 +54,43 @@
 
     describe "with --path and" do
       it "without any options" do
-        bundle "install --path vendor"
+        bundle! :install, forgotten_command_line_options(:path => "vendor")
         expect(out).to include(bundle_deployment_message)
         expect(out).to_not include("Gems in the group")
         expect(out).to include(bundle_complete_message)
       end
 
       it "with --without one group" do
-        bundle "install --without emo --path vendor"
+        bundle! :install, forgotten_command_line_options(:without => "emo", :path => "vendor")
         expect(out).to include(bundle_deployment_message)
         expect(out).to include("Gems in the group emo were not installed")
         expect(out).to include(bundle_complete_message)
       end
 
       it "with --without two groups" do
-        bundle "install --without emo test --path vendor"
+        bundle! :install, forgotten_command_line_options(:without => "emo test", :path => "vendor")
         expect(out).to include(bundle_deployment_message)
         expect(out).to include("Gems in the groups emo and test were not installed")
         expect(out).to include(bundle_complete_message)
       end
 
       it "with --without more groups" do
-        bundle "install --without emo obama test --path vendor"
+        bundle! :install, forgotten_command_line_options(:without => "emo obama test", :path => "vendor")
         expect(out).to include(bundle_deployment_message)
         expect(out).to include("Gems in the groups emo, obama and test were not installed")
         expect(out).to include(bundle_complete_message)
       end
 
       it "with an absolute --path inside the cwd" do
-        bundle "install --path #{bundled_app}/cache"
+        bundle! :install, forgotten_command_line_options(:path => bundled_app("cache"))
         expect(out).to include("Bundled gems are installed into ./cache")
         expect(out).to_not include("Gems in the group")
         expect(out).to include(bundle_complete_message)
       end
 
       it "with an absolute --path outside the cwd" do
-        bundle "install --path #{bundled_app}_cache"
-        expect(out).to include("Bundled gems are installed into #{bundled_app}_cache")
+        bundle! :install, forgotten_command_line_options(:path => tmp("not_bundled_app"))
+        expect(out).to include("Bundled gems are installed into #{tmp("not_bundled_app")}")
         expect(out).to_not include("Gems in the group")
         expect(out).to include(bundle_complete_message)
       end
@@ -146,8 +146,8 @@
     end
 
     it "with --without one group" do
-      bundle "install --without emo"
-      bundle :install
+      bundle! :install, forgotten_command_line_options(:without => "emo")
+      bundle! :install
       expect(out).to include(bundle_show_message)
       expect(out).to include("Gems in the group emo were not installed")
       expect(out).to include(bundle_complete_message)
@@ -155,15 +155,15 @@
     end
 
     it "with --without two groups" do
-      bundle "install --without emo test"
-      bundle :install
+      bundle! :install, forgotten_command_line_options(:without => "emo test")
+      bundle! :install
       expect(out).to include(bundle_show_message)
       expect(out).to include("Gems in the groups emo and test were not installed")
       expect(out).to include(bundle_complete_message)
     end
 
     it "with --without more groups" do
-      bundle "install --without emo obama test"
+      bundle! :install, forgotten_command_line_options(:without => "emo obama test")
       bundle :install
       expect(out).to include(bundle_show_message)
       expect(out).to include("Gems in the groups emo, obama and test were not installed")
@@ -179,21 +179,21 @@
     end
 
     it "with --without one group" do
-      bundle! :install, :without => :emo
+      bundle! :install, forgotten_command_line_options(:without => "emo")
       bundle! :update, :all => bundle_update_requires_all?
       expect(out).to include("Gems in the group emo were not installed")
       expect(out).to include(bundle_updated_message)
     end
 
     it "with --without two groups" do
-      bundle! "install --without emo test"
+      bundle! :install, forgotten_command_line_options(:without => "emo test")
       bundle! :update, :all => bundle_update_requires_all?
       expect(out).to include("Gems in the groups emo and test were not installed")
       expect(out).to include(bundle_updated_message)
     end
 
     it "with --without more groups" do
-      bundle! "install --without emo obama test"
+      bundle! :install, forgotten_command_line_options(:without => "emo obama test")
       bundle! :update, :all => bundle_update_requires_all?
       expect(out).to include("Gems in the groups emo, obama and test were not installed")
       expect(out).to include(bundle_updated_message)
diff --git a/spec/lock/lockfile_spec.rb b/spec/lock/lockfile_spec.rb
index d1b415395ad..14cf94bdb73 100644
--- a/spec/lock/lockfile_spec.rb
+++ b/spec/lock/lockfile_spec.rb
@@ -1239,7 +1239,7 @@
       gem "omg", :git => "#{lib_path("omg")}", :branch => 'master'
     G
 
-    bundle "install --path vendor"
+    bundle! :install, forgotten_command_line_options(:path => "vendor")
     expect(the_bundle).to include_gems "omg 1.0"
 
     # Create a Gemfile.lock that has duplicate GIT sections
diff --git a/spec/plugins/source/example_spec.rb b/spec/plugins/source/example_spec.rb
index b00c5b66d72..368c75702db 100644
--- a/spec/plugins/source/example_spec.rb
+++ b/spec/plugins/source/example_spec.rb
@@ -152,8 +152,8 @@ def install(spec, opts)
       end
 
       it "copies repository to vendor cache and uses it even when installed with bundle --path" do
-        bundle "install --path vendor/bundle"
-        bundle "cache --all"
+        bundle! :install, forgotten_command_line_options(:path => "vendor/bundle")
+        bundle! :cache, forgotten_command_line_options([:all, :cache_all] => true)
 
         expect(bundled_app("vendor/cache/a-path-gem-1.0-#{uri_hash}")).to exist
 
@@ -162,8 +162,8 @@ def install(spec, opts)
       end
 
       it "bundler package copies repository to vendor cache" do
-        bundle "install --path vendor/bundle"
-        bundle "package --all"
+        bundle! :install, forgotten_command_line_options(:path => "vendor/bundle")
+        bundle! :package, forgotten_command_line_options([:all, :cache_all] => true)
 
         expect(bundled_app("vendor/cache/a-path-gem-1.0-#{uri_hash}")).to exist
 
diff --git a/spec/quality_spec.rb b/spec/quality_spec.rb
index 8c90b331582..dcc518dce44 100644
--- a/spec/quality_spec.rb
+++ b/spec/quality_spec.rb
@@ -173,6 +173,7 @@ def check_for_specific_pronouns(filename)
       console_command
       default_cli_command
       deployment_means_frozen
+      forget_cli_options
       gem.coc
       gem.mit
       inline
@@ -185,6 +186,7 @@ def check_for_specific_pronouns(filename)
 
     Bundler::Settings::BOOL_KEYS.each {|k| all_settings[k] << "in Bundler::Settings::BOOL_KEYS" }
     Bundler::Settings::NUMBER_KEYS.each {|k| all_settings[k] << "in Bundler::Settings::NUMBER_KEYS" }
+    Bundler::Settings::ARRAY_KEYS.each {|k| all_settings[k] << "in Bundler::Settings::ARRAY_KEYS" }
 
     Dir.chdir(root) do
       key_pattern = /([a-z\._-]+)/i
diff --git a/spec/realworld/edgecases_spec.rb b/spec/realworld/edgecases_spec.rb
index fbf885778a6..aa60e20b8a2 100644
--- a/spec/realworld/edgecases_spec.rb
+++ b/spec/realworld/edgecases_spec.rb
@@ -239,7 +239,7 @@ def rubygems_version(name, requirement)
       gem 'rack', '1.0.1'
     G
 
-    bundle "install --path vendor/bundle"
+    bundle! :install, forgotten_command_line_options(:path => "vendor/bundle")
     expect(err).not_to include("Could not find rake")
     expect(err).to lack_errors
   end
diff --git a/spec/realworld/parallel_spec.rb b/spec/realworld/parallel_spec.rb
index 2f5bc9fbaf8..e8d9771b098 100644
--- a/spec/realworld/parallel_spec.rb
+++ b/spec/realworld/parallel_spec.rb
@@ -22,9 +22,6 @@
 
     bundle "show faker"
     expect(out).to match(/faker/)
-
-    bundle "config jobs"
-    expect(out).to match(/: "4"/)
   end
 
   it "updates" do
@@ -54,9 +51,6 @@
 
     bundle "show faker"
     expect(out).to match(/faker/)
-
-    bundle "config jobs"
-    expect(out).to match(/: "4"/)
   end
 
   it "works with --standalone" do
diff --git a/spec/runtime/executable_spec.rb b/spec/runtime/executable_spec.rb
index 5b5dbcdf057..545fc97330c 100644
--- a/spec/runtime/executable_spec.rb
+++ b/spec/runtime/executable_spec.rb
@@ -2,14 +2,14 @@
 
 RSpec.describe "Running bin/* commands" do
   before :each do
-    gemfile <<-G
+    install_gemfile! <<-G
       source "file://#{gem_repo1}"
       gem "rack"
     G
   end
 
   it "runs the bundled command when in the bundle" do
-    bundle "install --binstubs"
+    bundle! "binstubs rack"
 
     build_gem "rack", "2.0", :to_system => true do |s|
       s.executables = "rackup"
@@ -20,7 +20,7 @@
   end
 
   it "allows the location of the gem stubs to be specified" do
-    bundle "install --binstubs gbin"
+    bundle! "binstubs rack", :path => "gbin"
 
     expect(bundled_app("bin")).not_to exist
     expect(bundled_app("gbin/rackup")).to exist
@@ -30,24 +30,24 @@
   end
 
   it "allows absolute paths as a specification of where to install bin stubs" do
-    bundle "install --binstubs #{tmp}/bin"
+    bundle! "binstubs rack", :path => tmp("bin")
 
     gembin tmp("bin/rackup")
     expect(out).to eq("1.0.0")
   end
 
   it "uses the default ruby install name when shebang is not specified" do
-    bundle "install --binstubs"
+    bundle! "binstubs rack"
     expect(File.open("bin/rackup").gets).to eq("#!/usr/bin/env #{RbConfig::CONFIG["ruby_install_name"]}\n")
   end
 
   it "allows the name of the shebang executable to be specified" do
-    bundle "install --binstubs --shebang ruby-foo"
+    bundle! "binstubs rack", :shebang => "ruby-foo"
     expect(File.open("bin/rackup").gets).to eq("#!/usr/bin/env ruby-foo\n")
   end
 
   it "runs the bundled command when out of the bundle" do
-    bundle "install --binstubs"
+    bundle! "binstubs rack"
 
     build_gem "rack", "2.0", :to_system => true do |s|
       s.executables = "rackup"
@@ -68,7 +68,7 @@
       gem "rack", :path => "#{lib_path("rack")}"
     G
 
-    bundle "install --binstubs"
+    bundle! "binstubs rack"
 
     build_gem "rack", "2.0", :to_system => true do |s|
       s.executables = "rackup"
@@ -88,35 +88,35 @@
       gem "bundler"
     G
 
-    bundle "install --binstubs"
+    bundle "binstubs bundler"
 
     expect(bundled_app("bin/bundle")).not_to exist
   end
 
   it "does not generate bin stubs if the option was not specified" do
-    bundle "install"
+    bundle! "install"
 
     expect(bundled_app("bin/rackup")).not_to exist
   end
 
-  it "allows you to stop installing binstubs" do
-    bundle "install --binstubs bin/"
+  it "allows you to stop installing binstubs", :bundler => "< 2" do
+    bundle! "install --binstubs bin/"
     bundled_app("bin/rackup").rmtree
-    bundle "install --binstubs \"\""
+    bundle! "install --binstubs \"\""
 
     expect(bundled_app("bin/rackup")).not_to exist
 
-    bundle "config bin"
+    bundle! "config bin"
     expect(out).to include("You have not configured a value for `bin`")
   end
 
-  it "remembers that the option was specified" do
+  it "remembers that the option was specified", :bundler => "< 2" do
     gemfile <<-G
       source "file://#{gem_repo1}"
       gem "activesupport"
     G
 
-    bundle "install --binstubs"
+    bundle! :install, forgotten_command_line_options([:binstubs, :bin] => "bin")
 
     gemfile <<-G
       source "file://#{gem_repo1}"
@@ -129,13 +129,13 @@
     expect(bundled_app("bin/rackup")).to exist
   end
 
-  it "rewrites bins on --binstubs (to maintain backwards compatibility)" do
+  it "rewrites bins on --binstubs (to maintain backwards compatibility)", :bundler => "< 2" do
     gemfile <<-G
       source "file://#{gem_repo1}"
       gem "rack"
     G
 
-    bundle "install --binstubs bin/"
+    bundle! :install, forgotten_command_line_options([:binstubs, :bin] => "bin")
 
     File.open(bundled_app("bin/rackup"), "wb") do |file|
       file.print "OMG"
@@ -145,4 +145,17 @@
 
     expect(bundled_app("bin/rackup").read).to_not eq("OMG")
   end
+
+  it "rewrites bins on binstubs (to maintain backwards compatibility)" do
+    install_gemfile! <<-G
+      source "file://#{gem_repo1}"
+      gem "rack"
+    G
+
+    create_file("bin/rackup", "OMG")
+
+    bundle! "binstubs rack"
+
+    expect(bundled_app("bin/rackup").read).to_not eq("OMG")
+  end
 end
diff --git a/spec/runtime/setup_spec.rb b/spec/runtime/setup_spec.rb
index c6b2d1ff3f1..3f95399c2b2 100644
--- a/spec/runtime/setup_spec.rb
+++ b/spec/runtime/setup_spec.rb
@@ -495,13 +495,13 @@ def clean_load_path(lp)
     end
 
     it "works even when the cache directory has been deleted" do
-      bundle "install --path vendor/bundle"
+      bundle! :install, forgotten_command_line_options(:path => "vendor/bundle")
       FileUtils.rm_rf vendored_gems("cache")
       expect(the_bundle).to include_gems "rack 1.0.0"
     end
 
     it "does not randomly change the path when specifying --path and the bundle directory becomes read only" do
-      bundle "install --path vendor/bundle"
+      bundle! :install, forgotten_command_line_options(:path => "vendor/bundle")
 
       with_read_only("**/*") do
         expect(the_bundle).to include_gems "rack 1.0.0"
@@ -603,7 +603,7 @@ def clean_load_path(lp)
 
   describe "when excluding groups" do
     it "doesn't change the resolve if --without is used" do
-      install_gemfile <<-G, :without => :rails
+      install_gemfile <<-G, forgotten_command_line_options(:without => :rails)
         source "file://#{gem_repo1}"
         gem "activesupport"
 
@@ -618,7 +618,7 @@ def clean_load_path(lp)
     end
 
     it "remembers --without and does not bail on bare Bundler.setup" do
-      install_gemfile <<-G, :without => :rails
+      install_gemfile <<-G, forgotten_command_line_options(:without => :rails)
         source "file://#{gem_repo1}"
         gem "activesupport"
 
@@ -633,7 +633,7 @@ def clean_load_path(lp)
     end
 
     it "remembers --without and does not include groups passed to Bundler.setup" do
-      install_gemfile <<-G, :without => :rails
+      install_gemfile <<-G, forgotten_command_line_options(:without => :rails)
         source "file://#{gem_repo1}"
         gem "activesupport"
 
diff --git a/spec/support/helpers.rb b/spec/support/helpers.rb
index 8a81053da70..312e47d5460 100644
--- a/spec/support/helpers.rb
+++ b/spec/support/helpers.rb
@@ -51,7 +51,7 @@ def exitstatus
     end
 
     def bundle_update_requires_all?
-      !Bundler::VERSION.start_with?("1.")
+      Bundler::VERSION.start_with?("1.") ? nil : true
     end
 
     def in_app_root(&blk)
@@ -99,7 +99,8 @@ def bundle(cmd, options = {})
       with_sudo = options.delete(:sudo)
       sudo = with_sudo == :preserve_env ? "sudo -E" : "sudo" if with_sudo
 
-      options["no-color"] = true unless options.key?("no-color") || cmd.to_s =~ /\A(e|ex|exe|exec|conf|confi|config)(\s|\z)/
+      no_color = options.delete("no-color") { cmd.to_s !~ /\A(e|ex|exe|exec|conf|confi|config)(\s|\z)/ }
+      options["no-color"] = true if no_color
 
       bundle_bin = options.delete("bundle_bin") || File.expand_path("../../../exe/bundle", __FILE__)
 
@@ -134,7 +135,16 @@ def bundle(cmd, options = {})
       env = env.map {|k, v| "#{k}='#{v}'" }.join(" ")
 
       args = options.map do |k, v|
-        v == true ? " --#{k}" : " --#{k} #{v}" if v
+        case v
+        when nil
+          next
+        when true
+          " --#{k}"
+        when false
+          " --no-#{k}"
+        else
+          " --#{k} #{v}"
+        end
       end.join
 
       cmd = "#{env} #{sudo} #{Gem.ruby} #{load_path_str} #{requires_str} #{bundle_bin} #{cmd}#{args}"
@@ -142,6 +152,24 @@ def bundle(cmd, options = {})
     end
     bang :bundle
 
+    def forgotten_command_line_options(options)
+      remembered = Bundler::VERSION.split(".", 2).first == "1"
+      options = options.map do |k, v|
+        k = Array(k)[remembered ? 0 : -1]
+        v = '""' if v && v.to_s.empty?
+        [k, v]
+      end
+      return Hash[options] if remembered
+      options.each do |k, v|
+        if v.nil?
+          bundle! "config --delete #{k}"
+        else
+          bundle! "config --local #{k} #{v}"
+        end
+      end
+      {}
+    end
+
     def bundler(cmd, options = {})
       options["bundle_bin"] = File.expand_path("../../../exe/bundler", __FILE__)
       bundle(cmd, options)