diff --git a/rules.neon b/rules.neon
index 34f4b3b6..85fa027f 100644
--- a/rules.neon
+++ b/rules.neon
@@ -12,6 +12,7 @@ rules:
 	- mglaman\PHPStanDrupal\Rules\Drupal\LoadIncludes
 	- mglaman\PHPStanDrupal\Rules\Drupal\EntityQuery\EntityQueryHasAccessCheckRule
 	- mglaman\PHPStanDrupal\Rules\Drupal\TestClassesProtectedPropertyModulesRule
+	- mglaman\PHPStanDrupal\Rules\Drupal\NoRedundantTraitUseRule
 
 conditionalTags:
 	mglaman\PHPStanDrupal\Rules\Drupal\Tests\TestClassSuffixNameRule:
diff --git a/src/Rules/Drupal/NoRedundantTraitUseRule.php b/src/Rules/Drupal/NoRedundantTraitUseRule.php
new file mode 100644
index 00000000..13bba410
--- /dev/null
+++ b/src/Rules/Drupal/NoRedundantTraitUseRule.php
@@ -0,0 +1,143 @@
+<?php declare(strict_types=1);
+
+namespace mglaman\PHPStanDrupal\Rules\Drupal;
+
+use Exception;
+use PhpParser\Node;
+use PhpParser\Node\Stmt\Class_;
+use PhpParser\Node\Stmt\TraitUse;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+
+/**
+ * Disallows redundant trait usage when a trait is already included via another trait.
+ *
+ * This rule checks classes that use multiple traits and ensures that
+ * they don't use a trait that is already being used by another trait.
+ * For example, if trait A uses trait B, then a class shouldn't use both A and B.
+ *
+ * @implements Rule<Class_>
+ */
+class NoRedundantTraitUseRule implements Rule
+{
+    private const ERROR_MESSAGE = 'Class uses trait "%s" redundantly as it is already included via trait "%s".';
+
+    public function __construct(
+        private ReflectionProvider $reflectionProvider,
+    ) {
+    }
+
+    public function getNodeType(): string
+    {
+        return Class_::class;
+    }
+
+    public function processNode(Node $node, Scope $scope): array
+    {
+        $errors = [];
+
+        // Get all trait use statements from the class.
+        $traitUseNodes = array_filter($node->stmts, fn($stmt) => $stmt instanceof TraitUse);
+
+        if (count($traitUseNodes) < 2) {
+            // Need at least 2 traits to have redundancy.
+            return [];
+        }
+
+        // Collect all directly used trait names with their resolved names.
+        $directlyUsedTraits = [];
+        foreach ($traitUseNodes as $traitUseNode) {
+            foreach ($traitUseNode->traits as $trait) {
+                $traitName = $scope->resolveName($trait);
+                $directlyUsedTraits[] = $traitName;
+            }
+        }
+
+        // Build a map of trait -> [traits it uses] with full resolution.
+        $traitDependencies = [];
+        foreach ($directlyUsedTraits as $traitName) {
+            try {
+                if ($this->reflectionProvider->hasClass($traitName)) {
+                    $traitReflection = $this->reflectionProvider->getClass($traitName);
+                    if ($traitReflection->isTrait()) {
+                        $traitDependencies[$traitName] = $this->getAllTraitsUsedByTrait($traitName, []);
+                    }
+                }
+            } catch (Exception $e) {
+                // Skip traits that can't be reflected.
+                continue;
+            }
+        }
+
+        // Check for redundancies.
+        foreach ($directlyUsedTraits as $traitA) {
+            foreach ($directlyUsedTraits as $traitB) {
+                if ($traitA === $traitB) {
+                    continue;
+                }
+
+                // Check if traitA uses traitB (directly or transitively).
+                if (isset($traitDependencies[$traitA]) && in_array($traitB, $traitDependencies[$traitA], true)) {
+                    $shortNameA = basename(str_replace('\\', '/', $traitA));
+                    $shortNameB = basename(str_replace('\\', '/', $traitB));
+
+                    $errors[] = RuleErrorBuilder::message(sprintf(self::ERROR_MESSAGE, $shortNameB, $shortNameA))
+                        ->line($node->getStartLine())
+                        ->identifier('traits.redundantTraitUse')
+                        ->build();
+                    
+                    // Only report each redundant trait once
+                    break;
+                }
+            }
+        }
+
+        return $errors;
+    }
+
+    /**
+     * Get all traits used by a given trait recursively.
+     *
+     * @param string $traitName The fully qualified trait name.
+     * @param array<string> $visited Array to track visited traits (for cycle detection).
+     *
+     * @return array<string> Array of all trait names used by the given trait (directly and transitively).
+     */
+    private function getAllTraitsUsedByTrait(string $traitName, array $visited = []): array
+    {
+        // Prevent infinite loops.
+        if (in_array($traitName, $visited, true)) {
+            return [];
+        }
+        $visited[] = $traitName;
+
+        try {
+            if (!$this->reflectionProvider->hasClass($traitName)) {
+                return [];
+            }
+
+            $traitReflection = $this->reflectionProvider->getClass($traitName);
+            if (!$traitReflection->isTrait()) {
+                return [];
+            }
+
+            $allTraits = [];
+
+            // Get direct traits used by this trait.
+            foreach ($traitReflection->getTraits() as $trait) {
+                $usedTraitName = $trait->getName();
+                $allTraits[] = $usedTraitName;
+
+                // Recursively get traits used by the used trait.
+                $nestedTraits = $this->getAllTraitsUsedByTrait($usedTraitName, $visited);
+                $allTraits = array_merge($allTraits, $nestedTraits);
+            }
+
+            return array_unique($allTraits);
+        } catch (Exception $e) {
+            return [];
+        }
+    }
+}
diff --git a/tests/src/Rules/NoRedundantTraitUseRuleTest.php b/tests/src/Rules/NoRedundantTraitUseRuleTest.php
new file mode 100644
index 00000000..493b529a
--- /dev/null
+++ b/tests/src/Rules/NoRedundantTraitUseRuleTest.php
@@ -0,0 +1,58 @@
+<?php declare(strict_types=1);
+
+namespace mglaman\PHPStanDrupal\Tests\Rules;
+
+use mglaman\PHPStanDrupal\Rules\Drupal\NoRedundantTraitUseRule;
+use mglaman\PHPStanDrupal\Tests\DrupalRuleTestCase;
+use PHPStan\Reflection\ReflectionProvider;
+
+final class NoRedundantTraitUseRuleTest extends DrupalRuleTestCase
+{
+    protected function getRule(): \PHPStan\Rules\Rule
+    {
+        return new NoRedundantTraitUseRule($this->createReflectionProvider());
+    }
+
+    /**
+     * @dataProvider resultData
+     *
+     * @param list<array{0: string, 1: int, 2?: string|null}> $errorMessages
+     */
+    public function testRule(string $path, array $errorMessages): void
+    {
+        $this->analyse([$path], $errorMessages);
+    }
+
+    public static function resultData(): \Generator
+    {
+        yield [
+            __DIR__ . '/data/no-redundant-trait-use.php',
+            [
+                [
+                    'Class uses trait "BarTrait" redundantly as it is already included via trait "FooTrait".',
+                    20
+                ],
+            ]
+        ];
+
+        yield [
+            __DIR__ . '/data/no-redundant-trait-use-valid.php',
+            []
+        ];
+
+        yield [
+            __DIR__ . '/data/no-redundant-trait-use-single-trait.php',
+            []
+        ];
+
+        yield [
+            __DIR__ . '/data/no-redundant-trait-use-transitive.php',
+            [
+                [
+                    'Class uses trait "BaseTrait" redundantly as it is already included via trait "WrapperTrait".',
+                    20
+                ],
+            ]
+        ];
+    }
+}
\ No newline at end of file
diff --git a/tests/src/Rules/data/no-redundant-trait-use-single-trait.php b/tests/src/Rules/data/no-redundant-trait-use-single-trait.php
new file mode 100644
index 00000000..63a125d3
--- /dev/null
+++ b/tests/src/Rules/data/no-redundant-trait-use-single-trait.php
@@ -0,0 +1,14 @@
+<?php declare(strict_types=1);
+
+trait SingleTrait
+{
+    public function singleMethod(): void
+    {
+    }
+}
+
+// This class uses only one trait - this is valid (no redundancy possible)
+class SingleTraitUseClass
+{
+    use SingleTrait;
+}
\ No newline at end of file
diff --git a/tests/src/Rules/data/no-redundant-trait-use-transitive.php b/tests/src/Rules/data/no-redundant-trait-use-transitive.php
new file mode 100644
index 00000000..ea5f3e28
--- /dev/null
+++ b/tests/src/Rules/data/no-redundant-trait-use-transitive.php
@@ -0,0 +1,24 @@
+<?php declare(strict_types=1);
+
+trait BaseTrait
+{
+    public function baseMethod(): void
+    {
+    }
+}
+
+trait WrapperTrait
+{
+    use BaseTrait;
+
+    public function wrapperMethod(): void
+    {
+    }
+}
+
+// This class uses WrapperTrait and BaseTrait, but BaseTrait is already included via WrapperTrait
+class TransitiveRedundantTraitUseClass
+{
+    use WrapperTrait;
+    use BaseTrait; // This should trigger an error (transitive redundancy)
+}
\ No newline at end of file
diff --git a/tests/src/Rules/data/no-redundant-trait-use-valid.php b/tests/src/Rules/data/no-redundant-trait-use-valid.php
new file mode 100644
index 00000000..c9a29c9b
--- /dev/null
+++ b/tests/src/Rules/data/no-redundant-trait-use-valid.php
@@ -0,0 +1,22 @@
+<?php declare(strict_types=1);
+
+trait IndependentTrait1
+{
+    public function method1(): void
+    {
+    }
+}
+
+trait IndependentTrait2
+{
+    public function method2(): void
+    {
+    }
+}
+
+// This class uses two independent traits - this is valid
+class ValidTraitUseClass
+{
+    use IndependentTrait1;
+    use IndependentTrait2;
+}
\ No newline at end of file
diff --git a/tests/src/Rules/data/no-redundant-trait-use.php b/tests/src/Rules/data/no-redundant-trait-use.php
new file mode 100644
index 00000000..78464078
--- /dev/null
+++ b/tests/src/Rules/data/no-redundant-trait-use.php
@@ -0,0 +1,24 @@
+<?php declare(strict_types=1);
+
+trait BarTrait
+{
+    public function barMethod(): void
+    {
+    }
+}
+
+trait FooTrait
+{
+    use BarTrait;
+
+    public function fooMethod(): void
+    {
+    }
+}
+
+// This class uses both FooTrait and BarTrait, but BarTrait is already included via FooTrait
+class RedundantTraitUseClass
+{
+    use FooTrait;
+    use BarTrait; // This should trigger an error
+}
\ No newline at end of file