diff --git a/crates/biome_cli/src/execute/process_file/lint.rs b/crates/biome_cli/src/execute/process_file/lint.rs
index 91eecd29f672..8638d8b2a2d2 100644
--- a/crates/biome_cli/src/execute/process_file/lint.rs
+++ b/crates/biome_cli/src/execute/process_file/lint.rs
@@ -22,10 +22,16 @@ pub(crate) fn lint_with_guard<'ctx>(
         move || {
             let mut input = workspace_file.input()?;
             let mut changed = false;
+            let (only, skip) =
+                if let TraversalMode::Lint { only, skip, .. } = ctx.execution.traversal_mode() {
+                    (only.clone(), skip.clone())
+                } else {
+                    (Vec::new(), Vec::new())
+                };
             if let Some(fix_mode) = ctx.execution.as_fix_file_mode() {
                 let fix_result = workspace_file
                     .guard()
-                    .fix_file(*fix_mode, false)
+                    .fix_file(*fix_mode, false, only.clone(), skip.clone())
                     .with_file_path_and_code(
                         workspace_file.path.display().to_string(),
                         category!("lint"),
@@ -57,12 +63,6 @@ pub(crate) fn lint_with_guard<'ctx>(
             }
 
             let max_diagnostics = ctx.remaining_diagnostics.load(Ordering::Relaxed);
-            let (only, skip) =
-                if let TraversalMode::Lint { only, skip, .. } = ctx.execution.traversal_mode() {
-                    (only.clone(), skip.clone())
-                } else {
-                    (Vec::new(), Vec::new())
-                };
             let pull_diagnostics_result = workspace_file
                 .guard()
                 .pull_diagnostics(
diff --git a/crates/biome_cli/src/execute/std_in.rs b/crates/biome_cli/src/execute/std_in.rs
index ecdb12d0d69d..840c882a77d5 100644
--- a/crates/biome_cli/src/execute/std_in.rs
+++ b/crates/biome_cli/src/execute/std_in.rs
@@ -108,12 +108,20 @@ pub(crate) fn run<'a>(
             return Ok(());
         };
 
+        let (only, skip) = if let TraversalMode::Lint { only, skip, .. } = mode.traversal_mode() {
+            (only.clone(), skip.clone())
+        } else {
+            (Vec::new(), Vec::new())
+        };
+
         if let Some(fix_file_mode) = mode.as_fix_file_mode() {
             if file_features.supports_lint() {
                 let fix_file_result = workspace.fix_file(FixFileParams {
                     fix_file_mode: *fix_file_mode,
                     path: biome_path.clone(),
                     should_format: mode.is_check() && file_features.supports_format(),
+                    only: only.clone(),
+                    skip: skip.clone(),
                 })?;
                 let code = fix_file_result.code;
                 let output = match biome_path.extension_as_str() {
@@ -156,11 +164,6 @@ pub(crate) fn run<'a>(
             }
         }
 
-        let (only, skip) = if let TraversalMode::Lint { only, skip, .. } = mode.traversal_mode() {
-            (only.clone(), skip.clone())
-        } else {
-            (Vec::new(), Vec::new())
-        };
         if !mode.is_check_apply_unsafe() {
             let result = workspace.pull_diagnostics(PullDiagnosticsParams {
                 categories: RuleCategoriesBuilder::default()
diff --git a/crates/biome_cli/tests/commands/lint.rs b/crates/biome_cli/tests/commands/lint.rs
index 3b641565d003..b3a7a4578f86 100644
--- a/crates/biome_cli/tests/commands/lint.rs
+++ b/crates/biome_cli/tests/commands/lint.rs
@@ -3806,6 +3806,46 @@ fn lint_only_group_with_disabled_rule() {
     ));
 }
 
+#[test]
+fn lint_only_write() {
+    let mut fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+    let config = r#"{}"#;
+    let content = r#"
+    export const z = function (array) {
+        array.map((sentence) => sentence.split(" ")).flat();
+        return 0;
+    };
+    "#;
+
+    let file_path = Path::new("check.js");
+    fs.insert(file_path.into(), content.as_bytes());
+    let config_path = Path::new("biome.json");
+    fs.insert(config_path.into(), config.as_bytes());
+
+    let result = run_cli(
+        DynRef::Borrowed(&mut fs),
+        &mut console,
+        Args::from(
+            [
+                ("lint"),
+                "--write",
+                "--only=complexity/useArrowFunction",
+                file_path.as_os_str().to_str().unwrap(),
+            ]
+            .as_slice(),
+        ),
+    );
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "lint_only_write",
+        fs,
+        console,
+        result,
+    ));
+}
+
 #[test]
 fn lint_skip_rule() {
     let mut fs = MemoryFileSystem::default();
@@ -3943,6 +3983,46 @@ fn lint_skip_rule_and_group() {
     ));
 }
 
+#[test]
+fn lint_skip_write() {
+    let mut fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+    let config = r#"{}"#;
+    let content = r#"
+    export const z = function (array) {
+        array.map((sentence) => sentence.split(" ")).flat();
+        return 0;
+    };
+    "#;
+
+    let file_path = Path::new("check.js");
+    fs.insert(file_path.into(), content.as_bytes());
+    let config_path = Path::new("biome.json");
+    fs.insert(config_path.into(), config.as_bytes());
+
+    let result = run_cli(
+        DynRef::Borrowed(&mut fs),
+        &mut console,
+        Args::from(
+            [
+                ("lint"),
+                "--write",
+                "--skip=complexity/useArrowFunction",
+                file_path.as_os_str().to_str().unwrap(),
+            ]
+            .as_slice(),
+        ),
+    );
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "lint_skip_write",
+        fs,
+        console,
+        result,
+    ));
+}
+
 #[test]
 fn lint_only_group_skip_rule() {
     let mut fs = MemoryFileSystem::default();
diff --git a/crates/biome_cli/tests/snapshots/main_commands_lint/lint_only_write.snap b/crates/biome_cli/tests/snapshots/main_commands_lint/lint_only_write.snap
new file mode 100644
index 000000000000..23aac6f49400
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_commands_lint/lint_only_write.snap
@@ -0,0 +1,26 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: content
+---
+## `biome.json`
+
+```json
+{}
+```
+
+## `check.js`
+
+```js
+
+    export const z = (array) => {
+        array.map((sentence) => sentence.split(" ")).flat();
+        return 0;
+    };
+    
+```
+
+# Emitted Messages
+
+```block
+Checked 1 file in <TIME>. Fixed 1 file.
+```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_lint/lint_skip_write.snap b/crates/biome_cli/tests/snapshots/main_commands_lint/lint_skip_write.snap
new file mode 100644
index 000000000000..9ad9f2ec0b93
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_commands_lint/lint_skip_write.snap
@@ -0,0 +1,26 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: content
+---
+## `biome.json`
+
+```json
+{}
+```
+
+## `check.js`
+
+```js
+
+    export const z = function (array) {
+        array.flatMap((sentence) => sentence.split(" "));
+        return 0;
+    };
+    
+```
+
+# Emitted Messages
+
+```block
+Checked 1 file in <TIME>. Fixed 1 file.
+```
diff --git a/crates/biome_lsp/src/handlers/analysis.rs b/crates/biome_lsp/src/handlers/analysis.rs
index 920f8c4b0237..1a8f23148fa4 100644
--- a/crates/biome_lsp/src/handlers/analysis.rs
+++ b/crates/biome_lsp/src/handlers/analysis.rs
@@ -237,6 +237,8 @@ fn fix_all(
         path: biome_path,
         fix_file_mode: FixFileMode::SafeFixes,
         should_format,
+        only: vec![],
+        skip: vec![],
     })?;
 
     if fixed.actions.is_empty() {
diff --git a/crates/biome_service/src/file_handlers/css.rs b/crates/biome_service/src/file_handlers/css.rs
index 21abbf24c4bd..a7a469047a0d 100644
--- a/crates/biome_service/src/file_handlers/css.rs
+++ b/crates/biome_service/src/file_handlers/css.rs
@@ -167,7 +167,7 @@ impl ServiceLanguage for CssLanguage {
             rules: global
                 .map(|g| to_analyzer_rules(g, file_path.as_path()))
                 .unwrap_or_default(),
-            globals: vec![],
+            globals: Vec::new(),
             preferred_quote,
             jsx_runtime: None,
         };
@@ -362,7 +362,7 @@ fn lint(params: LintParams) -> LintResults {
                         .collect::<Vec<_>>()
                 }
             } else {
-                vec![]
+                Vec::new()
             };
 
             let mut syntax_visitor = SyntaxVisitor::default();
@@ -499,7 +499,9 @@ pub(crate) fn code_actions(params: CodeActionsParams) -> PullActionsResult {
 
             let Some(_) = language.to_css_file_source() else {
                 error!("Could not determine the file source of the file");
-                return PullActionsResult { actions: vec![] };
+                return PullActionsResult {
+                    actions: Vec::new(),
+                };
             };
 
             trace!("CSS runs the analyzer");
@@ -526,45 +528,60 @@ pub(crate) fn code_actions(params: CodeActionsParams) -> PullActionsResult {
 
 /// If applies all the safe fixes to the given syntax tree.
 pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceError> {
-    let FixAllParams {
-        parse,
-        fix_file_mode,
-        workspace,
-        should_format,
-        biome_path,
-        manifest: _,
-        document_file_source,
-    } = params;
-
-    let settings = workspace.settings();
-    let Some(settings) = settings else {
-        let tree: CssRoot = parse.tree();
-
+    let mut tree: CssRoot = params.parse.tree();
+    let Some(settings) = params.workspace.settings() else {
         return Ok(FixFileResult {
-            actions: vec![],
+            actions: Vec::new(),
             errors: 0,
             skipped_suggested_fixes: 0,
             code: tree.syntax().to_string(),
         });
     };
 
-    let mut tree: CssRoot = parse.tree();
-    let mut actions = Vec::new();
-
     // Compute final rules (taking `overrides` into account)
     let rules = settings.as_rules(params.biome_path.as_path());
-    let rule_filter_list = rules
-        .as_ref()
-        .map(|rules| rules.as_enabled_rules())
-        .unwrap_or_default()
+
+    let mut enabled_rules = if !params.only.is_empty() {
+        params
+            .only
+            .into_iter()
+            .map(|selector| selector.into())
+            .collect::<Vec<_>>()
+    } else {
+        rules
+            .as_ref()
+            .map(|rules| rules.as_enabled_rules())
+            .unwrap_or_default()
+            .into_iter()
+            .collect::<Vec<_>>()
+    };
+
+    let mut syntax_visitor = SyntaxVisitor::default();
+    visit_registry(&mut syntax_visitor);
+    enabled_rules.extend(syntax_visitor.enabled_rules);
+
+    let disabled_rules = params
+        .skip
         .into_iter()
+        .map(|selector| selector.into())
         .collect::<Vec<_>>();
-    let filter = AnalysisFilter::from_enabled_rules(rule_filter_list.as_slice());
 
+    let filter = AnalysisFilter {
+        categories: RuleCategoriesBuilder::default()
+            .with_syntax()
+            .with_lint()
+            .build(),
+        enabled_rules: Some(enabled_rules.as_slice()),
+        disabled_rules: &disabled_rules,
+        range: None,
+    };
+
+    let mut actions = Vec::new();
     let mut skipped_suggested_fixes = 0;
     let mut errors: u16 = 0;
-    let analyzer_options =
-        workspace.analyzer_options::<CssLanguage>(biome_path, &document_file_source);
+    let analyzer_options = params
+        .workspace
+        .analyzer_options::<CssLanguage>(params.biome_path, &params.document_file_source);
     loop {
         let (action, _) = analyze(&tree, filter, &analyzer_options, |signal| {
             let current_diagnostic = signal.diagnostic();
@@ -581,7 +598,7 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
                     continue;
                 }
 
-                match fix_file_mode {
+                match params.fix_file_mode {
                     FixFileMode::SafeFixes => {
                         if action.applicability == Applicability::MaybeIncorrect {
                             skipped_suggested_fixes += 1;
@@ -632,9 +649,12 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
                 }
             }
             None => {
-                let code = if should_format {
+                let code = if params.should_format {
                     format_node(
-                        workspace.format_options::<CssLanguage>(biome_path, &document_file_source),
+                        params.workspace.format_options::<CssLanguage>(
+                            params.biome_path,
+                            &params.document_file_source,
+                        ),
                         tree.syntax(),
                     )?
                     .print()?
diff --git a/crates/biome_service/src/file_handlers/graphql.rs b/crates/biome_service/src/file_handlers/graphql.rs
index 8a01b9fc605b..630fa04c9e58 100644
--- a/crates/biome_service/src/file_handlers/graphql.rs
+++ b/crates/biome_service/src/file_handlers/graphql.rs
@@ -320,19 +320,19 @@ fn lint(params: LintParams) -> LintResults {
                         .collect::<Vec<_>>()
                 }
             } else {
-                vec![]
+                Vec::new()
             };
 
+            let mut syntax_visitor = SyntaxVisitor::default();
+            visit_registry(&mut syntax_visitor);
+            enabled_rules.extend(syntax_visitor.enabled_rules);
+
             let disabled_rules = params
                 .skip
                 .into_iter()
                 .map(|selector| selector.into())
                 .collect::<Vec<_>>();
 
-            let mut syntax_visitor = SyntaxVisitor::default();
-            visit_registry(&mut syntax_visitor);
-            enabled_rules.extend(syntax_visitor.enabled_rules);
-
             let filter = AnalysisFilter {
                 categories: params.categories,
                 enabled_rules: Some(enabled_rules.as_slice()),
@@ -451,7 +451,9 @@ pub(crate) fn code_actions(params: CodeActionsParams) -> PullActionsResult {
 
             let Some(_) = language.to_graphql_file_source() else {
                 error!("Could not determine the file source of the file");
-                return PullActionsResult { actions: vec![] };
+                return PullActionsResult {
+                    actions: Vec::new(),
+                };
             };
 
             trace!("GraphQL runs the analyzer");
@@ -478,45 +480,59 @@ pub(crate) fn code_actions(params: CodeActionsParams) -> PullActionsResult {
 
 /// If applies all the safe fixes to the given syntax tree.
 pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceError> {
-    let FixAllParams {
-        parse,
-        fix_file_mode,
-        workspace,
-        should_format: _, // we don't have a formatter yet
-        biome_path,
-        manifest: _,
-        document_file_source,
-    } = params;
-
-    let settings = workspace.settings();
-    let Some(settings) = settings else {
-        let tree: GraphqlRoot = parse.tree();
-
+    let mut tree: GraphqlRoot = params.parse.tree();
+    let Some(settings) = params.workspace.settings() else {
         return Ok(FixFileResult {
-            actions: vec![],
+            actions: Vec::new(),
             errors: 0,
             skipped_suggested_fixes: 0,
             code: tree.syntax().to_string(),
         });
     };
 
-    let mut tree: GraphqlRoot = parse.tree();
-    let mut actions = Vec::new();
-
     // Compute final rules (taking `overrides` into account)
     let rules = settings.as_rules(params.biome_path.as_path());
-    let rule_filter_list = rules
-        .as_ref()
-        .map(|rules| rules.as_enabled_rules())
-        .unwrap_or_default()
+    let mut enabled_rules = if !params.only.is_empty() {
+        params
+            .only
+            .into_iter()
+            .map(|selector| selector.into())
+            .collect::<Vec<_>>()
+    } else {
+        rules
+            .as_ref()
+            .map(|rules| rules.as_enabled_rules())
+            .unwrap_or_default()
+            .into_iter()
+            .collect::<Vec<_>>()
+    };
+
+    let mut syntax_visitor = SyntaxVisitor::default();
+    visit_registry(&mut syntax_visitor);
+    enabled_rules.extend(syntax_visitor.enabled_rules);
+
+    let disabled_rules = params
+        .skip
         .into_iter()
+        .map(|selector| selector.into())
         .collect::<Vec<_>>();
-    let filter = AnalysisFilter::from_enabled_rules(rule_filter_list.as_slice());
 
+    let filter = AnalysisFilter {
+        categories: RuleCategoriesBuilder::default()
+            .with_syntax()
+            .with_lint()
+            .build(),
+        enabled_rules: Some(enabled_rules.as_slice()),
+        disabled_rules: &disabled_rules,
+        range: None,
+    };
+
+    let mut actions = Vec::new();
     let mut skipped_suggested_fixes = 0;
     let mut errors: u16 = 0;
-    let analyzer_options =
-        workspace.analyzer_options::<GraphqlLanguage>(biome_path, &document_file_source);
+    let analyzer_options = params
+        .workspace
+        .analyzer_options::<GraphqlLanguage>(params.biome_path, &params.document_file_source);
     loop {
         let (action, _) = analyze(&tree, filter, &analyzer_options, |signal| {
             let current_diagnostic = signal.diagnostic();
@@ -533,7 +549,7 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
                     continue;
                 }
 
-                match fix_file_mode {
+                match params.fix_file_mode {
                     FixFileMode::SafeFixes => {
                         if action.applicability == Applicability::MaybeIncorrect {
                             skipped_suggested_fixes += 1;
@@ -584,6 +600,7 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
                 }
             }
             None => {
+                // we don't have a formatter yet
                 // let code = if should_format {
                 //     format_node(
                 //         workspace.format_options::<GraphqlLanguage>(biome_path, &document_file_source),
diff --git a/crates/biome_service/src/file_handlers/javascript.rs b/crates/biome_service/src/file_handlers/javascript.rs
index 740b6712c19a..f66648634a6a 100644
--- a/crates/biome_service/src/file_handlers/javascript.rs
+++ b/crates/biome_service/src/file_handlers/javascript.rs
@@ -211,7 +211,7 @@ impl ServiceLanguage for JsLanguage {
                 .unwrap_or_default();
 
         let mut jsx_runtime = None;
-        let mut globals = vec![];
+        let mut globals = Vec::new();
 
         if let (Some(overrides), Some(global)) = (overrides, global) {
             jsx_runtime = Some(
@@ -411,7 +411,7 @@ pub(crate) fn lint(params: LintParams) -> LintResults {
             else {
                 return LintResults {
                     errors: 0,
-                    diagnostics: vec![],
+                    diagnostics: Vec::new(),
                     skipped_diagnostics: 0,
                 };
             };
@@ -430,33 +430,35 @@ pub(crate) fn lint(params: LintParams) -> LintResults {
             }
 
             let has_only_filter = !params.only.is_empty();
-            let enabled_rules = if has_only_filter {
+            let mut enabled_rules = if has_only_filter {
                 params
                     .only
                     .into_iter()
                     .map(|selector| selector.into())
                     .collect::<Vec<_>>()
             } else {
-                let mut rule_filter_list = rules
+                let mut enabled_rules = rules
                     .as_ref()
                     .map(|rules| rules.as_enabled_rules())
                     .unwrap_or_default()
                     .into_iter()
                     .collect::<Vec<_>>();
                 if organize_imports_enabled && !params.categories.is_syntax() {
-                    rule_filter_list.push(RuleFilter::Rule("correctness", "organizeImports"));
+                    enabled_rules.push(RuleFilter::Rule("correctness", "organizeImports"));
                 }
-                let mut syntax_visitor = SyntaxVisitor::default();
-                visit_registry(&mut syntax_visitor);
-                rule_filter_list.extend(syntax_visitor.enabled_rules);
-
-                rule_filter_list
+                enabled_rules
             };
+
+            let mut syntax_visitor = SyntaxVisitor::default();
+            visit_registry(&mut syntax_visitor);
+            enabled_rules.extend(syntax_visitor.enabled_rules);
+
             let disabled_rules = params
                 .skip
                 .into_iter()
                 .map(|selector| selector.into())
                 .collect::<Vec<_>>();
+
             let filter = AnalysisFilter {
                 categories: params.categories,
                 enabled_rules: Some(enabled_rules.as_slice()),
@@ -589,7 +591,7 @@ pub(crate) fn code_actions(params: CodeActionsParams) -> PullActionsResult {
                 workspace.analyzer_options::<JsLanguage>(params.path, &params.language);
             let rules = settings.as_rules(params.path);
             let mut actions = Vec::new();
-            let mut enabled_rules = vec![];
+            let mut enabled_rules = Vec::new();
             if settings.organize_imports.enabled {
                 enabled_rules.push(RuleFilter::Rule("correctness", "organizeImports"));
             }
@@ -621,7 +623,9 @@ pub(crate) fn code_actions(params: CodeActionsParams) -> PullActionsResult {
 
             let Some(source_type) = language.to_js_file_source() else {
                 error!("Could not determine the file source of the file");
-                return PullActionsResult { actions: vec![] };
+                return PullActionsResult {
+                    actions: Vec::new(),
+                };
             };
 
             trace!("Javascript runs the analyzer");
@@ -653,64 +657,68 @@ pub(crate) fn code_actions(params: CodeActionsParams) -> PullActionsResult {
 
 /// If applies all the safe fixes to the given syntax tree.
 pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceError> {
-    let FixAllParams {
-        parse,
-        // rules,
-        fix_file_mode,
-        should_format,
-        biome_path,
-        // mut filter,
-        manifest,
-        document_file_source,
-        workspace,
-    } = params;
-
-    let settings = workspace.settings();
-    let Some(settings) = settings else {
-        let tree: AnyJsRoot = parse.tree();
-
+    let mut tree: AnyJsRoot = params.parse.tree();
+    let Some(settings) = params.workspace.settings() else {
         return Ok(FixFileResult {
-            actions: vec![],
+            actions: Vec::new(),
             errors: 0,
             skipped_suggested_fixes: 0,
             code: tree.syntax().to_string(),
         });
     };
+
     // Compute final rules (taking `overrides` into account)
     let rules = settings.as_rules(params.biome_path.as_path());
-    let rule_filter_list = rules
-        .as_ref()
-        .map(|rules| rules.as_enabled_rules())
-        .unwrap_or_default()
+    let enabled_rules = if !params.only.is_empty() {
+        params
+            .only
+            .into_iter()
+            .map(|selector| selector.into())
+            .collect::<Vec<_>>()
+    } else {
+        rules
+            .as_ref()
+            .map(|rules| rules.as_enabled_rules())
+            .unwrap_or_default()
+            .into_iter()
+            .collect::<Vec<_>>()
+    };
+    let disabled_rules = params
+        .skip
         .into_iter()
+        .map(|selector| selector.into())
         .collect::<Vec<_>>();
-    let mut filter = AnalysisFilter::from_enabled_rules(rule_filter_list.as_slice());
+    let filter = AnalysisFilter {
+        categories: RuleCategoriesBuilder::default()
+            .with_syntax()
+            .with_lint()
+            .build(),
+        enabled_rules: Some(enabled_rules.as_slice()),
+        disabled_rules: &disabled_rules,
+        range: None,
+    };
 
-    let Some(file_source) = document_file_source
+    let Some(file_source) = params
+        .document_file_source
         .to_js_file_source()
-        .or(JsFileSource::try_from(biome_path.as_path()).ok())
+        .or(JsFileSource::try_from(params.biome_path.as_path()).ok())
     else {
-        return Err(extension_error(biome_path));
+        return Err(extension_error(params.biome_path));
     };
-    let mut tree: AnyJsRoot = parse.tree();
-    let mut actions = Vec::new();
-
-    filter.categories = RuleCategoriesBuilder::default()
-        .with_syntax()
-        .with_lint()
-        .build();
 
+    let mut actions = Vec::new();
     let mut skipped_suggested_fixes = 0;
     let mut errors: u16 = 0;
-    let analyzer_options =
-        workspace.analyzer_options::<JsLanguage>(biome_path, &document_file_source);
+    let analyzer_options = params
+        .workspace
+        .analyzer_options::<JsLanguage>(params.biome_path, &params.document_file_source);
     loop {
         let (action, _) = analyze(
             &tree,
             filter,
             &analyzer_options,
             file_source,
-            manifest.clone(),
+            params.manifest.clone(),
             |signal| {
                 let current_diagnostic = signal.diagnostic();
 
@@ -726,7 +734,7 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
                         continue;
                     }
 
-                    match fix_file_mode {
+                    match params.fix_file_mode {
                         FixFileMode::SafeFixes => {
                             if action.applicability == Applicability::MaybeIncorrect {
                                 skipped_suggested_fixes += 1;
@@ -778,9 +786,12 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
                 }
             }
             None => {
-                let code = if should_format {
+                let code = if params.should_format {
                     format_node(
-                        workspace.format_options::<JsLanguage>(biome_path, &document_file_source),
+                        params.workspace.format_options::<JsLanguage>(
+                            params.biome_path,
+                            &params.document_file_source,
+                        ),
                         tree.syntax(),
                     )?
                     .print()?
diff --git a/crates/biome_service/src/file_handlers/mod.rs b/crates/biome_service/src/file_handlers/mod.rs
index 9500d6a8bed2..7e9b76fb13ba 100644
--- a/crates/biome_service/src/file_handlers/mod.rs
+++ b/crates/biome_service/src/file_handlers/mod.rs
@@ -345,6 +345,8 @@ pub struct FixAllParams<'a> {
     pub(crate) biome_path: &'a BiomePath,
     pub(crate) manifest: Option<PackageJson>,
     pub(crate) document_file_source: DocumentFileSource,
+    pub(crate) only: Vec<RuleSelector>,
+    pub(crate) skip: Vec<RuleSelector>,
 }
 
 #[derive(Default)]
diff --git a/crates/biome_service/src/workspace.rs b/crates/biome_service/src/workspace.rs
index ee323bd49cf1..0a24fb787a18 100644
--- a/crates/biome_service/src/workspace.rs
+++ b/crates/biome_service/src/workspace.rs
@@ -608,6 +608,8 @@ pub struct FixFileParams {
     pub path: BiomePath,
     pub fix_file_mode: FixFileMode,
     pub should_format: bool,
+    pub only: Vec<RuleSelector>,
+    pub skip: Vec<RuleSelector>,
 }
 
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
@@ -1023,11 +1025,15 @@ impl<'app, W: Workspace + ?Sized> FileGuard<'app, W> {
         &self,
         fix_file_mode: FixFileMode,
         should_format: bool,
+        only: Vec<RuleSelector>,
+        skip: Vec<RuleSelector>,
     ) -> Result<FixFileResult, WorkspaceError> {
         self.workspace.fix_file(FixFileParams {
             path: self.path.clone(),
             fix_file_mode,
             should_format,
+            only,
+            skip,
         })
     }
 
diff --git a/crates/biome_service/src/workspace/server.rs b/crates/biome_service/src/workspace/server.rs
index 9fab2264ca61..cd74e67b3450 100644
--- a/crates/biome_service/src/workspace/server.rs
+++ b/crates/biome_service/src/workspace/server.rs
@@ -759,6 +759,8 @@ impl Workspace for WorkspaceServer {
             biome_path: &params.path,
             manifest,
             document_file_source: language,
+            only: params.only,
+            skip: params.skip,
         })
     }
 
diff --git a/packages/@biomejs/backend-jsonrpc/src/workspace.ts b/packages/@biomejs/backend-jsonrpc/src/workspace.ts
index de07e2a5cfec..a6838a751b8c 100644
--- a/packages/@biomejs/backend-jsonrpc/src/workspace.ts
+++ b/packages/@biomejs/backend-jsonrpc/src/workspace.ts
@@ -2896,8 +2896,10 @@ export interface FormatOnTypeParams {
 }
 export interface FixFileParams {
 	fix_file_mode: FixFileMode;
+	only: RuleCode[];
 	path: BiomePath;
 	should_format: boolean;
+	skip: RuleCode[];
 }
 /**
  * Which fixes should be applied during the analyzing phase