diff --git a/docs/insights/complexity.md b/docs/insights/complexity.md
index c6268c4a..e53925d8 100644
--- a/docs/insights/complexity.md
+++ b/docs/insights/complexity.md
@@ -1,12 +1,12 @@
 # Complexity
 
-For now the Complexity section is only one Insight in one Metric:
+For now the Complexity section is only one Metric consisting of multiple insights:
 
 * `NunoMaduro\PhpInsights\Domain\Metrics\Complexity\Complexity` <Badge text="Complexity" type="warn" vertical="middle"/>
 
-## Cyclomatic Complexity is high <Badge text="^1.0"/> <Badge text="Complexity" type="warn"/>
+## Class Cyclomatic Complexity is high <Badge text="^1.0"/> <Badge text="Complexity" type="warn"/>
 
-This insight checks complexity cyclomatic on your classes, the lower the score the easier your code is to understand. It raises an issue if complexity is over `5`.
+This insight checks total method cyclomatic complexity of each class, the lower the score the easier your code is to understand. It raises an issue if complexity is over `5`.
 
 **Insight Class**: `NunoMaduro\PhpInsights\Domain\Insights\CyclomaticComplexityIsHigh`
 
@@ -20,6 +20,38 @@ This insight checks complexity cyclomatic on your classes, the lower the score t
 ```
 </details>
 
+## Average Class Method Cyclomatic Complexity is high <Badge text="^2.12"/> <Badge text="Complexity" type="warn"/>
+
+This insight checks average class method cyclomatic complexity, the lower the score the easier your code is to understand. It raises an issue if complexity is over `5.0`.
+
+**Insight Class**: `NunoMaduro\PhpInsights\Domain\Insights\ClassMethodAverageCyclomaticComplexityIsHigh`
+
+<details>
+    <summary>Configuration</summary>
+
+```php
+\NunoMaduro\PhpInsights\Domain\Insights\ClassMethodAverageCyclomaticComplexityIsHigh::class => [
+     'maxClassMethodAverageComplexity' => 5.0,
+]
+```
+</details>
+
+## Method Cyclomatic Complexity is high <Badge text="^2.12"/> <Badge text="Complexity" type="warn"/>
+
+This insight checks cyclomatic complexity of your methods, the lower the score the easier your code is to understand. It raises an issue if complexity is over `5`.
+
+**Insight Class**: `NunoMaduro\PhpInsights\Domain\Insights\MethodCyclomaticComplexityIsHigh`
+
+<details>
+    <summary>Configuration</summary>
+
+```php
+\NunoMaduro\PhpInsights\Domain\Insights\MethodCyclomaticComplexityIsHigh::class => [
+     'maxMethodComplexity' => 5,
+]
+```
+</details>
+
 <!--
 Insight template
 ##  <Badge text="^1.0"/> <Badge text="Complexity" type="warn"/>
diff --git a/src/Domain/Collector.php b/src/Domain/Collector.php
index d151171e..5e3c4905 100644
--- a/src/Domain/Collector.php
+++ b/src/Domain/Collector.php
@@ -69,7 +69,7 @@ final class Collector
     private int $totalMethodComplexity = 0;
 
     /**
-     * @var array<int>
+     * @var array<string, int>
      */
     private array $methodComplexity = [];
 
@@ -486,7 +486,15 @@ public function getLogicalLines(): int
         return $this->logicalLines;
     }
 
-    public function getMethodComplexity(): int
+    /**
+     * @return array<string, int>
+     */
+    public function getMethodComplexity(): array
+    {
+        return $this->methodComplexity;
+    }
+
+    public function getTotalMethodComplexity(): int
     {
         return $this->totalMethodComplexity;
     }
diff --git a/src/Domain/Insights/ClassMethodAverageCyclomaticComplexityIsHigh.php b/src/Domain/Insights/ClassMethodAverageCyclomaticComplexityIsHigh.php
new file mode 100644
index 00000000..edef57ef
--- /dev/null
+++ b/src/Domain/Insights/ClassMethodAverageCyclomaticComplexityIsHigh.php
@@ -0,0 +1,104 @@
+<?php
+
+declare(strict_types=1);
+
+namespace NunoMaduro\PhpInsights\Domain\Insights;
+
+use NunoMaduro\PhpInsights\Domain\Contracts\GlobalInsight;
+use NunoMaduro\PhpInsights\Domain\Contracts\HasDetails;
+use NunoMaduro\PhpInsights\Domain\Details;
+
+/**
+ * @see \Tests\Domain\Insights\ClassMethodAverageCyclomaticComplexityIsHighTest
+ */
+final class ClassMethodAverageCyclomaticComplexityIsHigh extends Insight implements HasDetails, GlobalInsight
+{
+    /**
+     * @var array<Details>
+     */
+    private array $details = [];
+
+    public function hasIssue(): bool
+    {
+        return $this->details !== [];
+    }
+
+    public function getTitle(): string
+    {
+        return sprintf(
+            'Having `classes` with average method cyclomatic complexity more than %s is prohibited - Consider refactoring',
+            $this->getMaxComplexity()
+        );
+    }
+
+    /**
+     * @return array<int, Details>
+     */
+    public function getDetails(): array
+    {
+        return $this->details;
+    }
+
+    public function process(): void
+    {
+        // Exclude in collector all excluded files
+        if ($this->excludedFiles !== []) {
+            $this->collector->excludeComplexityFiles($this->excludedFiles);
+        }
+
+        $averageClassComplexity = $this->getAverageClassComplexity();
+
+        // Exclude the ones which didn't pass the threshold
+        $complexityLimit = $this->getMaxComplexity();
+        $averageClassComplexity = array_filter(
+            $averageClassComplexity,
+            static fn ($complexity): bool => $complexity > $complexityLimit
+        );
+
+        $this->details = array_map(
+            static fn ($class, $complexity): Details => Details::make()
+                ->setFile($class)
+                ->setMessage(sprintf('%.2f cyclomatic complexity', $complexity)),
+            array_keys($averageClassComplexity),
+            $averageClassComplexity
+        );
+    }
+
+    private function getMaxComplexity(): float
+    {
+        return (float) ($this->config['maxClassMethodAverageComplexity'] ?? 5.0);
+    }
+
+    private function getFile(string $classMethod): string
+    {
+        $colonPosition = strpos($classMethod, ':');
+
+        if ($colonPosition !== false) {
+            return substr($classMethod, 0, $colonPosition);
+        }
+
+        return $classMethod;
+    }
+
+    /**
+     * @return array<string, float>
+     */
+    private function getAverageClassComplexity(): array
+    {
+        // Group method complexities by files
+        $classComplexities = [];
+
+        foreach ($this->collector->getMethodComplexity() as $classMethod => $complexity) {
+            $classComplexities[$this->getFile($classMethod)][] = $complexity;
+        }
+
+        // Calculate average complexity of each file
+        $averageClassComplexity = [];
+
+        foreach ($classComplexities as $file => $complexities) {
+            $averageClassComplexity[$file] = array_sum($complexities) / count($complexities);
+        }
+
+        return $averageClassComplexity;
+    }
+}
diff --git a/src/Domain/Insights/CyclomaticComplexityIsHigh.php b/src/Domain/Insights/CyclomaticComplexityIsHigh.php
index f14393e0..ff097811 100644
--- a/src/Domain/Insights/CyclomaticComplexityIsHigh.php
+++ b/src/Domain/Insights/CyclomaticComplexityIsHigh.php
@@ -26,11 +26,14 @@ public function hasIssue(): bool
     public function getTitle(): string
     {
         return sprintf(
-            'Having `classes` with more than %s cyclomatic complexity is prohibited - Consider refactoring',
+            'Having `classes` with total cyclomatic complexity more than %s is prohibited - Consider refactoring',
             $this->getMaxComplexity()
         );
     }
 
+    /**
+     * @return array<int, Details>
+     */
     public function getDetails(): array
     {
         return $this->details;
@@ -49,9 +52,13 @@ public function process(): void
             static fn ($complexity): bool => $complexity > $complexityLimit
         );
 
-        $this->details = array_map(static fn ($class, $complexity): Details => Details::make()
-            ->setFile($class)
-            ->setMessage("{$complexity} cyclomatic complexity"), array_keys($classesComplexity), $classesComplexity);
+        $this->details = array_map(
+            static fn ($class, $complexity): Details => Details::make()
+                ->setFile($class)
+                ->setMessage(sprintf('%d cyclomatic complexity', $complexity)),
+            array_keys($classesComplexity),
+            $classesComplexity
+        );
     }
 
     private function getMaxComplexity(): int
diff --git a/src/Domain/Insights/MethodCyclomaticComplexityIsHigh.php b/src/Domain/Insights/MethodCyclomaticComplexityIsHigh.php
new file mode 100644
index 00000000..1640285d
--- /dev/null
+++ b/src/Domain/Insights/MethodCyclomaticComplexityIsHigh.php
@@ -0,0 +1,88 @@
+<?php
+
+declare(strict_types=1);
+
+namespace NunoMaduro\PhpInsights\Domain\Insights;
+
+use NunoMaduro\PhpInsights\Domain\Contracts\GlobalInsight;
+use NunoMaduro\PhpInsights\Domain\Contracts\HasDetails;
+use NunoMaduro\PhpInsights\Domain\Details;
+
+/**
+ * @see \Tests\Domain\Insights\MethodCyclomaticComplexityIsHighTest
+ */
+final class MethodCyclomaticComplexityIsHigh extends Insight implements HasDetails, GlobalInsight
+{
+    /**
+     * @var array<Details>
+     */
+    private array $details = [];
+
+    public function hasIssue(): bool
+    {
+        return $this->details !== [];
+    }
+
+    public function getTitle(): string
+    {
+        return sprintf(
+            'Having `methods` with cyclomatic complexity more than %s is prohibited - Consider refactoring',
+            $this->getMaxComplexity()
+        );
+    }
+
+    /**
+     * @return array<int, Details>
+     */
+    public function getDetails(): array
+    {
+        return $this->details;
+    }
+
+    public function process(): void
+    {
+        // Exclude in collector all excluded files
+        if ($this->excludedFiles !== []) {
+            $this->collector->excludeComplexityFiles($this->excludedFiles);
+        }
+        $complexityLimit = $this->getMaxComplexity();
+
+        $methodComplexity = array_filter(
+            $this->collector->getMethodComplexity(),
+            static fn ($complexity): bool => $complexity > $complexityLimit
+        );
+
+        $this->details = array_map(
+            fn ($class, $complexity): Details => $this->getDetailsForClassMethod($class, $complexity),
+            array_keys($methodComplexity),
+            $methodComplexity
+        );
+    }
+
+    private function getMaxComplexity(): int
+    {
+        return (int) ($this->config['maxMethodComplexity'] ?? 5);
+    }
+
+    private function getDetailsForClassMethod(string $class, int $complexity): Details
+    {
+        $file = $class;
+        $function = null;
+        $colonPosition = strpos($class, ':');
+
+        if ($colonPosition !== false) {
+            $file = substr($class, 0, $colonPosition);
+            $function = substr($class, $colonPosition + 1);
+        }
+
+        $details = Details::make()
+            ->setFile($file)
+            ->setMessage(sprintf('%d cyclomatic complexity', $complexity));
+
+        if ($function !== null) {
+            $details->setFunction($function);
+        }
+
+        return $details;
+    }
+}
diff --git a/src/Domain/Metrics/Complexity/Complexity.php b/src/Domain/Metrics/Complexity/Complexity.php
index 68216146..56753e66 100644
--- a/src/Domain/Metrics/Complexity/Complexity.php
+++ b/src/Domain/Metrics/Complexity/Complexity.php
@@ -7,7 +7,9 @@
 use NunoMaduro\PhpInsights\Domain\Collector;
 use NunoMaduro\PhpInsights\Domain\Contracts\HasAvg;
 use NunoMaduro\PhpInsights\Domain\Contracts\HasInsights;
+use NunoMaduro\PhpInsights\Domain\Insights\ClassMethodAverageCyclomaticComplexityIsHigh;
 use NunoMaduro\PhpInsights\Domain\Insights\CyclomaticComplexityIsHigh;
+use NunoMaduro\PhpInsights\Domain\Insights\MethodCyclomaticComplexityIsHigh;
 
 final class Complexity implements HasAvg, HasInsights
 {
@@ -23,6 +25,8 @@ public function getInsights(): array
     {
         return [
             CyclomaticComplexityIsHigh::class,
+            ClassMethodAverageCyclomaticComplexityIsHigh::class,
+            MethodCyclomaticComplexityIsHigh::class,
         ];
     }
 }
diff --git a/src/Domain/Results.php b/src/Domain/Results.php
index a5c95c31..3287b22f 100644
--- a/src/Domain/Results.php
+++ b/src/Domain/Results.php
@@ -48,14 +48,7 @@ public function getCodeQuality(): float
      */
     public function getComplexity(): float
     {
-        $avg = $this->collector->getAverageComplexityPerMethod() - 1.0;
-
-        return (float) number_format(
-            100.0 - max(min($avg * 100.0 / 3.0, 100.0), 0.0),
-            1,
-            '.',
-            ''
-        );
+        return $this->getPercentageForComplexity();
     }
 
     /**
@@ -162,6 +155,32 @@ private function getPercentage(string $category): float
         return (float) number_format($percentage, 1, '.', '');
     }
 
+    /**
+     * Returns the percentage of the given category.
+     */
+    private function getPercentageForComplexity(): float
+    {
+        // Calculate total number of files multiplied by number of insights for complexity metric
+        $complexityInsights = $this->perCategoryInsights['Complexity'] ?? [];
+        $totalFiles = count($this->collector->getFiles()) * count($complexityInsights);
+
+        // For each metric count the number of files with problem
+        $filesWithProblems = 0;
+
+        foreach ($complexityInsights as $insight) {
+            if ($insight instanceof HasDetails) {
+                $filesWithProblems += count($insight->getDetails());
+            }
+        }
+
+        // Percentage result is 100% - percentage of files with problems
+        $percentage = $totalFiles > 0
+            ? 100 - ($filesWithProblems * 100 / $totalFiles)
+            : 100;
+
+        return (float) number_format($percentage, 1, '.', '');
+    }
+
     private function getInsightByCategory(string $insightClass, string $category): Insight
     {
         foreach ($this->perCategoryInsights[$category] ?? [] as $insight) {
diff --git a/tests/Domain/Insights/ClassMethodAverageCyclomaticComplexityIsHighTest.php b/tests/Domain/Insights/ClassMethodAverageCyclomaticComplexityIsHighTest.php
new file mode 100644
index 00000000..3e648eec
--- /dev/null
+++ b/tests/Domain/Insights/ClassMethodAverageCyclomaticComplexityIsHighTest.php
@@ -0,0 +1,88 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Domain\Insights;
+
+use NunoMaduro\PhpInsights\Application\Console\Formatters\PathShortener;
+use NunoMaduro\PhpInsights\Domain\Analyser;
+use NunoMaduro\PhpInsights\Domain\Collector;
+use NunoMaduro\PhpInsights\Domain\Insights\ClassMethodAverageCyclomaticComplexityIsHigh;
+use NunoMaduro\PhpInsights\Domain\Metrics\Complexity\Complexity;
+use Tests\TestCase;
+
+final class ClassMethodAverageCyclomaticComplexityIsHighTest extends TestCase
+{
+    public function testMethodHasNoCyclomaticComplexity(): void
+    {
+        $path = __DIR__ . '/Fixtures/';
+        $collector = new Collector([$path], PathShortener::extractCommonPath([$path]));
+        $insight = new ClassMethodAverageCyclomaticComplexityIsHigh($collector, []);
+
+        self::assertFalse($insight->hasIssue());
+        self::assertCount(0, $insight->getDetails());
+    }
+
+    public function testMethodHasToMuchCyclomaticComplexity(): void
+    {
+        $files = [
+            __DIR__ . '/Fixtures/ClassWithHighMethodAverageComplexity.php',
+        ];
+
+        $commonPath = PathShortener::extractCommonPath($files);
+
+        $analyzer = new Analyser();
+        $collector = $analyzer->analyse([__DIR__ . '/Fixtures/'], $files, $commonPath);
+        $insight = new ClassMethodAverageCyclomaticComplexityIsHigh($collector, []);
+        $insight->process();
+
+        self::assertTrue($insight->hasIssue());
+        self::assertIsArray($insight->getDetails());
+        self::assertCount(1, $insight->getDetails());
+
+        $message = $insight->getDetails()[0]->getMessage() ?? '';
+        $file = $insight->getDetails()[0]->getFile() ?? '';
+
+        self::assertStringContainsString('ClassWithHighMethodAverageComplexity.php', $file);
+        self::assertSame('5.33 cyclomatic complexity', $message);
+    }
+
+    public function testMethodWeCanConfigureTheMaxComplexity(): void
+    {
+        $files = [
+            __DIR__ . '/Fixtures/ClassWithHighMethodAverageComplexity.php',
+        ];
+
+        $commonPath = PathShortener::extractCommonPath($files);
+
+        $analyzer = new Analyser();
+        $collector = $analyzer->analyse([__DIR__ . '/Fixtures/'], $files, $commonPath);
+        $insight = new ClassMethodAverageCyclomaticComplexityIsHigh($collector, ['maxClassMethodAverageComplexity' => 10]);
+        $insight->process();
+
+        self::assertFalse($insight->hasIssue());
+        self::assertIsArray($insight->getDetails());
+        self::assertCount(0, $insight->getDetails());
+    }
+
+    public function testItNoReturnIssueWhenFileExcluded(): void
+    {
+        $fileLocation = __DIR__ . '/Fixtures/ClassWithHighMethodAverageComplexity.php';
+        $collection = $this->runAnalyserOnConfig(
+            [
+                'config' => [
+                    ClassMethodAverageCyclomaticComplexityIsHigh::class => [
+                        'exclude' => [$fileLocation],
+                    ],
+                ],
+            ],
+            [$fileLocation]
+        );
+
+        foreach ($collection->allFrom(new Complexity()) as $insight) {
+            if ($insight->getInsightClass() === ClassMethodAverageCyclomaticComplexityIsHigh::class) {
+                self::assertFalse($insight->hasIssue());
+            }
+        }
+    }
+}
diff --git a/tests/Domain/Insights/Fixtures/ClassWithComplexMethod.php b/tests/Domain/Insights/Fixtures/ClassWithComplexMethod.php
new file mode 100644
index 00000000..92e5419b
--- /dev/null
+++ b/tests/Domain/Insights/Fixtures/ClassWithComplexMethod.php
@@ -0,0 +1,34 @@
+<?php
+
+
+namespace Tests\Domain\Insights\Fixtures;
+
+
+class ClassWithComplexMethod
+{
+
+    public function first(int $first)
+    {
+        if ($first === 1) {
+            return 1;
+        }
+
+        if ($first === 2) {
+            return 2;
+        }
+
+        if ($first === 3) {
+            return 3;
+        }
+
+        if ($first === 4) {
+            return 4;
+        }
+
+        if ($first === 5) {
+            return 5;
+        }
+
+        return $first;
+    }
+}
diff --git a/tests/Domain/Insights/Fixtures/ClassWithHighMethodAverageComplexity.php b/tests/Domain/Insights/Fixtures/ClassWithHighMethodAverageComplexity.php
new file mode 100644
index 00000000..dbdfb137
--- /dev/null
+++ b/tests/Domain/Insights/Fixtures/ClassWithHighMethodAverageComplexity.php
@@ -0,0 +1,76 @@
+<?php
+
+
+namespace Tests\Domain\Insights\Fixtures;
+
+
+class ClassWithHighMethodAverageComplexity
+{
+
+    public function first(int $first)
+    {
+        if ($first === 1) {
+            return 1;
+        }
+
+        if ($first === 2) {
+            return 2;
+        }
+
+        if ($first === 3) {
+            return 3;
+        }
+
+        if ($first === 4) {
+            return 4;
+        }
+
+        if ($first === 5) {
+            return 5;
+        }
+
+        return $first;
+    }
+
+    public function second(int $second)
+    {
+        if ($second === 1) {
+            return 1;
+        }
+
+        if ($second === 2) {
+            return 2;
+        }
+
+        if ($second === 3) {
+            return 3;
+        }
+
+        return $second;
+    }
+
+    public function third(int $third)
+    {
+        if ($third === 1) {
+            return 1;
+        }
+
+        if ($third === 2) {
+            return 2;
+        }
+
+        if ($third === 3) {
+            return 3;
+        }
+
+        if ($third === 4) {
+            return 4;
+        }
+
+        if ($third === 5) {
+            return 5;
+        }
+
+        return $third;
+    }
+}
diff --git a/tests/Domain/Insights/MethodCyclomaticComplexityIsHighTest.php b/tests/Domain/Insights/MethodCyclomaticComplexityIsHighTest.php
new file mode 100644
index 00000000..6f2666b9
--- /dev/null
+++ b/tests/Domain/Insights/MethodCyclomaticComplexityIsHighTest.php
@@ -0,0 +1,90 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Domain\Insights;
+
+use NunoMaduro\PhpInsights\Application\Console\Formatters\PathShortener;
+use NunoMaduro\PhpInsights\Domain\Analyser;
+use NunoMaduro\PhpInsights\Domain\Collector;
+use NunoMaduro\PhpInsights\Domain\Insights\MethodCyclomaticComplexityIsHigh;
+use NunoMaduro\PhpInsights\Domain\Metrics\Complexity\Complexity;
+use Tests\TestCase;
+
+final class MethodCyclomaticComplexityIsHighTest extends TestCase
+{
+    public function testMethodHasNoCyclomaticComplexity(): void
+    {
+        $path = __DIR__ . '/Fixtures/';
+        $collector = new Collector([$path], PathShortener::extractCommonPath([$path]));
+        $insight = new MethodCyclomaticComplexityIsHigh($collector, []);
+
+        self::assertFalse($insight->hasIssue());
+        self::assertCount(0, $insight->getDetails());
+    }
+
+    public function testMethodHasToMuchCyclomaticComplexity(): void
+    {
+        $files = [
+            __DIR__ . '/Fixtures/ClassWithComplexMethod.php',
+        ];
+
+        $commonPath = PathShortener::extractCommonPath($files);
+
+        $analyzer = new Analyser();
+        $collector = $analyzer->analyse([__DIR__ . '/Fixtures/'], $files, $commonPath);
+        $insight = new MethodCyclomaticComplexityIsHigh($collector, []);
+        $insight->process();
+
+        self::assertTrue($insight->hasIssue());
+        self::assertIsArray($insight->getDetails());
+        self::assertCount(1, $insight->getDetails());
+
+        $message = $insight->getDetails()[0]->getMessage() ?? '';
+        $file = $insight->getDetails()[0]->getFile() ?? '';
+        $function = $insight->getDetails()[0]->getFunction() ?? '';
+
+        self::assertStringContainsString('ClassWithComplexMethod.php', $file);
+        self::assertSame('first', $function);
+        self::assertSame('6 cyclomatic complexity', $message);
+    }
+
+    public function testMethodWeCanConfigureTheMaxComplexity(): void
+    {
+        $files = [
+            __DIR__ . '/Fixtures/ClassWithComplexMethod.php',
+        ];
+
+        $commonPath = PathShortener::extractCommonPath($files);
+
+        $analyzer = new Analyser();
+        $collector = $analyzer->analyse([__DIR__ . '/Fixtures/'], $files, $commonPath);
+        $insight = new MethodCyclomaticComplexityIsHigh($collector, ['maxMethodComplexity' => 10]);
+        $insight->process();
+
+        self::assertFalse($insight->hasIssue());
+        self::assertIsArray($insight->getDetails());
+        self::assertCount(0, $insight->getDetails());
+    }
+
+    public function testItNoReturnIssueWhenFileExcluded(): void
+    {
+        $fileLocation = __DIR__ . '/Fixtures/ClassWithComplexMethod.php';
+        $collection = $this->runAnalyserOnConfig(
+            [
+                'config' => [
+                    MethodCyclomaticComplexityIsHigh::class => [
+                        'exclude' => [$fileLocation],
+                    ],
+                ],
+            ],
+            [$fileLocation]
+        );
+
+        foreach ($collection->allFrom(new Complexity()) as $insight) {
+            if ($insight->getInsightClass() === MethodCyclomaticComplexityIsHigh::class) {
+                self::assertFalse($insight->hasIssue());
+            }
+        }
+    }
+}