         -> Result<[File], CommandantError<()>> {
             return getFiles(with: visitor)
                 .flatMap { groupFiles($0, visitor: visitor) }
-                .flatMap { visit(filesPerConfiguration: $0, visitor: visitor, storage: storage) }
+                .map { linters(for: $0, visitor: visitor) }
+                .map { collect(linters: $0, visitor: visitor, storage: storage) }
+                .map { visit(linters: $0, visitor: visitor, storage: storage) }
     }
 
     private func groupFiles(_ files: [File],

            }
            linters += files.map { visitor.linter(forFile: $0, configuration: newConfig) }
        }
        if visitor.parallel {
            let collectedLinters = linters.parallelCompactMap(transform: collect)
            DispatchQueue.concurrentPerform(iterations: fileCount) { index in
                let linter = collectedLinters[index]
                visit(linter)
            }
        } else {
            let collectedLinters = linters.compactMap(collect)
            collectedLinters.forEach(visit)
        }
        return .success(linters.compactMap({ $0.file }))
    }

    fileprivate func getFiles(with visitor: LintableFilesVisitor) -> Result<[File], CommandantError<()>> {

        return .success(groupedFiles)
    }

    private func linters(for filesPerConfiguration: [Configuration: [File]],
                         visitor: LintableFilesVisitor) -> [Linter] {
        let fileCount = filesPerConfiguration.reduce(0) { $0 + $1.value.count }

        var linters = [Linter]()
        linters.reserveCapacity(fileCount)
        for (config, files) in filesPerConfiguration {
