{
  "schema_version": "1.1.0",
  "data_version": "1.0.0",
  "infrastructure_without_implementation": {
    "id": "infrastructure_without_implementation",
    "version": "1.0.0",
    "name": "Infrastructure Without Implementation",
    "description": "Building custom solutions when standard APIs/SDKs exist and haven't been tested",
    "severity": "high",
    "category": "architectural",
    "detection_threshold": 0.5,
    "indicators": [
      {
        "regex": "\\b(?:custom|build|implement|create)\\s+(?:our\\s+own|new|custom)\\s+(?:http|client|server|api|wrapper)",
        "description": "mentions building custom infrastructure",
        "weight": 0.4,
        "text": "custom infrastructure"
      },
      {
        "regex": "\\b(?:build|implement|create)\\s+(?:custom|our\\s+own)",
        "description": "planning custom implementation",
        "weight": 0.4,
        "text": "custom implementation"
      },
      {
        "regex": "\\b(?:planning|going)\\s+to\\s+(?:build|implement|create)\\s+(?:a\\s+custom|our\\s+own)",
        "description": "planning custom solution",
        "weight": 0.3,
        "text": "planning custom solution"
      },
      {
        "regex": "\\bsdk\\s+(?:might\\s+be|is|could\\s+be)\\s+(?:limiting|limited|insufficient)",
        "description": "assumes SDK limitations without testing",
        "weight": 0.3,
        "text": "SDK limitations assumed"
      },
      {
        "regex": "\\b(?:instead\\s+of|rather\\s+than|avoid)\\s+(?:using|their)\\s+(?:sdk|api|library)",
        "description": "avoiding standard approach",
        "weight": 0.4,
        "text": "avoiding standard approach"
      },
      {
        "regex": "\\b(?:might\\s+not\\s+work|may\\s+not\\s+work|probably\\s+won't|likely\\s+won't)\\b",
        "description": "assumes failure without testing",
        "weight": 0.3,
        "text": "assumes failure without testing"
      },
      {
        "regex": "\\b(?:need|want)\\s+(?:more|full|better)\\s+(?:control|flexibility)",
        "description": "desires control without justification",
        "weight": 0.2,
        "text": "wants more control"
      },
      {
        "regex": "\\b(?:might\\s+be|could\\s+be|probably)\\s+(?:too\\s+)?(?:limiting|limited|restrictive)",
        "description": "assumes limitations without validation",
        "weight": 0.3,
        "text": "assumes limitations"
      },
      {
        "regex": "\\bwon't\\s+meet\\s+(?:our|the)\\s+(?:requirements|needs)",
        "description": "assumes inadequacy without testing",
        "weight": 0.3,
        "text": "assumes inadequacy"
      },
      {
        "regex": "\\b(?:I'll|we'll)\\s+(?:implement|create|build)\\s+(?:our\\s+own|a\\s+custom)",
        "description": "direct statement of custom implementation",
        "weight": 0.3,
        "text": "states custom implementation"
      },
      {
        "regex": "\\bmore\\s+features\\s+than\\s+(?:what\\s+)?(?:standard|typical|most)",
        "description": "assumes standard solutions insufficient",
        "weight": 0.3,
        "text": "assumes standard insufficient"
      },
      {
        "regex": "\\b(?:sophisticated|advanced|enterprise-grade|multi-layered)\\s+(?:system|solution|architecture)",
        "description": "over-engineering indicators",
        "weight": 0.3,
        "text": "over-engineering"
      },
      {
        "regex": "\\b(?:simple|basic)\\s+(?:library|solution|approach)\\s+won't",
        "description": "dismisses simple solutions",
        "weight": 0.3,
        "text": "dismisses simple solutions"
      }
    ],
    "negative_indicators": [
      {
        "regex": "\\bofficial\\s+(?:sdk|api|library|documentation)",
        "description": "mentions official SDK research",
        "weight": -0.3
      },
      {
        "regex": "\\b(?:tested|tried|reviewed)\\s+(?:the|their)\\s+(?:sdk|api|documentation)",
        "description": "shows evidence of testing standard approach",
        "weight": -0.4
      },
      {
        "regex": "\\bdocumentation\\s+(?:shows|says|recommends|suggests)",
        "description": "references official documentation",
        "weight": -0.2
      },
      {
        "regex": "\\b(?:completed|finished|implemented|done|shipped)\\s+(?:the\\s+)?(?:issue|feature|story|ticket|task|pr|pull\\s+request)\\s*#?\\d+",
        "description": "completion report with issue/task reference",
        "weight": -0.8
      },
      {
        "regex": "\\b(?:just|already|successfully)?\\s*(?:completed|finished|implemented|shipped|deployed|released)\\s+(?:the\\s+)?(?:implementation|feature|change|update|integration)",
        "description": "general completion indicator",
        "weight": -0.7
      },
      {
        "regex": "\\b(?:did\\s+i\\s+miss|what\\s+did\\s+i\\s+miss|anything\\s+(?:i\\s+)?(?:missed|forgot)|feedback\\s+on|review\\s+(?:of|this)|thoughts\\s+on|look\\s+good)",
        "description": "review request indicator",
        "weight": -0.6
      },
      {
        "regex": "\\b(?:changed|updated|modified)\\s+from\\s+.+\\s+to\\s+",
        "description": "describes completed changes",
        "weight": -0.5
      },
      {
        "regex": "\\b(?:here's|this\\s+is)\\s+(?:what\\s+i|the)\\s+(?:did|implemented|built|created)",
        "description": "presenting completed work",
        "weight": -0.6
      },
      {
        "regex": "\\b(?:strategy|approach|method|process)\\s+(?:update|change|migration|refactor)",
        "description": "business process change description",
        "weight": -0.4
      },
      {
        "regex": "\\bfollowing\\s+(?:the\\s+)?(?:plan|design|requirements|specification|issue)",
        "description": "indicates following existing plan",
        "weight": -0.3
      }
    ]
  },
  "symptom_driven_development": {
    "id": "symptom_driven_development",
    "version": "1.0.0", 
    "name": "Symptom-Driven Development",
    "description": "Addressing symptoms rather than root causes",
    "severity": "medium",
    "category": "process",
    "detection_threshold": 0.6,
    "indicators": [
      {
        "regex": "\\b(?:workaround|hack|quick\\s+fix|band-aid|patch)",
        "description": "mentions temporary solutions",
        "weight": 0.3,
        "text": "temporary solution"
      },
      {
        "regex": "\\bfor\\s+now\\b|\\btemporarily\\b|\\bas\\s+a\\s+quick\\s+fix",
        "description": "temporary language",
        "weight": 0.2,
        "text": "temporary approach"
      },
      {
        "regex": "\\b(?:error|exception|bug)\\s+(?:handling|catching)\\s+(?:to\\s+ignore|to\\s+suppress)",
        "description": "suppressing errors without fixing cause",
        "weight": 0.4,
        "text": "error suppression"
      }
    ]
  },
  "complexity_escalation": {
    "id": "complexity_escalation",
    "version": "1.0.0",
    "name": "Complexity Escalation", 
    "description": "Adding complexity instead of questioning necessity",
    "severity": "medium",
    "category": "design",
    "detection_threshold": 0.5,
    "indicators": [
      {
        "regex": "\\b(?:complex|sophisticated|advanced)\\s+(?:logic|system|architecture)",
        "description": "mentions complex systems",
        "weight": 0.2,
        "text": "complex system"
      },
      {
        "regex": "\\bmultiple\\s+(?:layers|services|components)\\s+(?:to\\s+handle|for)",
        "description": "multiple layers for simple functionality",
        "weight": 0.3,
        "text": "multiple layers"
      },
      {
        "regex": "\\b(?:enterprise|scalable|robust)\\s+(?:solution|architecture|pattern)",
        "description": "over-engineering indicators",
        "weight": 0.2,
        "text": "over-engineering"
      }
    ]
  },
  "documentation_neglect": {
    "id": "documentation_neglect",
    "version": "1.0.0",
    "name": "Documentation Neglect",
    "description": "Building solutions without researching standard approaches",
    "severity": "medium", 
    "category": "process",
    "detection_threshold": 0.4,
    "indicators": [
      {
        "regex": "\\b(?:couldn't\\s+find|no|lack\\s+of|missing)\\s+(?:documentation|examples|guides)",
        "description": "claims lack of documentation",
        "weight": 0.3,
        "text": "claims no documentation"
      },
      {
        "regex": "\\b(?:figure\\s+out|work\\s+out)\\s+(?:ourselves|how\\s+to)",
        "description": "planning to figure it out without research",
        "weight": 0.2,
        "text": "skipping research"
      }
    ]
  },
  "integration_over_engineering": {
    "id": "integration_over_engineering",
    "version": "1.0.0",
    "name": "Integration Over-Engineering",
    "description": "Building custom integration solutions when official alternatives exist",
    "severity": "high",
    "category": "integration",
    "detection_threshold": 0.5,
    "technologies": {
      "cognee": {
        "official_solution": "cognee/cognee:main Docker container with built-in REST API",
        "red_flags": ["custom server", "fastapi server", "custom REST server", "environment forcing", "manual JWT", "storage path fixes"],
        "features": ["REST API", "JWT authentication", "storage management"]
      },
      "supabase": {
        "official_solution": "Supabase official SDKs (@supabase/supabase-js, supabase-py)",
        "red_flags": ["custom auth", "manual database", "custom HTTP client"],
        "features": ["Authentication", "Database", "Storage", "Real-time"]
      },
      "openai": {
        "official_solution": "OpenAI Python SDK",
        "red_flags": ["HTTP client", "API wrapper", "custom retry", "manual requests"],
        "features": ["Chat completions", "Embeddings", "Error handling", "Streaming"]
      },
      "claude": {
        "official_solution": "Anthropic Python SDK",
        "red_flags": ["custom HTTP", "manual API", "custom client"],
        "features": ["Messages API", "Function calling", "Streaming", "Vision"]
      }
    },
    "indicators": [
      {
        "regex": "\\b(?:cognee|supabase|openai|claude|anthropic)\\b.*\\b(?:custom|build|implement|create)\\s+(?:server|client|wrapper|integration)",
        "description": "custom development for known technology",
        "weight": 0.5,
        "text": "custom integration for known tech"
      },
      {
        "regex": "\\b(?:FastAPI|flask|express)\\s+(?:server|app)\\s+for\\s+(?:cognee|supabase|openai|claude)",
        "description": "building custom server for technology with official solutions",
        "weight": 0.6,
        "text": "custom server for managed service"
      },
      {
        "regex": "\\b(?:JWT|authentication|auth)\\s+(?:implementation|handling|management)\\s+for\\s+(?:cognee|supabase)",
        "description": "manual auth implementation for services that provide it",
        "weight": 0.5,
        "text": "manual auth for managed auth service"
      },
      {
        "regex": "\\b(?:storage|database|db)\\s+(?:configuration|setup|management)\\s+(?:for|with)\\s+(?:cognee|supabase)",
        "description": "manual storage setup for managed storage services",
        "weight": 0.4,
        "text": "manual storage for managed service"
      },
      {
        "regex": "\\b(?:environment|env)\\s+(?:variable|var)\\s+(?:forcing|override|hack|workaround)",
        "description": "environment variable workarounds",
        "weight": 0.3,
        "text": "environment forcing"
      },
      {
        "regex": "\\b(?:docker|container)\\s+(?:build|create|setup)\\s+(?:for|with)\\s+(?:cognee|supabase)",
        "description": "custom container for services with official containers",
        "weight": 0.5,
        "text": "custom container for managed service"
      },
      {
        "regex": "\\b(?:requests|urllib|http\\.client)\\s+(?:for|to)\\s+(?:openai|claude|anthropic|supabase)",
        "description": "manual HTTP clients for services with official SDKs",
        "weight": 0.4,
        "text": "manual HTTP for SDK service"
      }
    ],
    "negative_indicators": [
      {
        "regex": "\\bofficial\\s+(?:docker|container|image)\\s+(?:tested|tried|using)",
        "description": "mentions testing official containers",
        "weight": -0.4
      },
      {
        "regex": "\\bofficial\\s+(?:sdk|library|client)\\s+(?:tested|tried|using|installed)",
        "description": "mentions using official SDKs",
        "weight": -0.5
      },
      {
        "regex": "\\b(?:@supabase/supabase-js|supabase-py|openai|anthropic)\\s+(?:sdk|library|client)",
        "description": "mentions specific official libraries",
        "weight": -0.6
      }
    ]
  },
  "effort_value_mismatch": {
    "id": "effort_value_mismatch",
    "version": "1.0.0",
    "name": "Effort-Value Mismatch",
    "description": "Disproportionate development effort for standard integration tasks",
    "severity": "medium",
    "category": "integration",
    "detection_threshold": 0.4,
    "indicators": [
      {
        "regex": "\\b(?:[0-9]{3,})\\s+(?:lines|loc)\\b.*\\b(?:integration|auth|api|client)",
        "description": "high line count for integration work",
        "weight": 0.4,
        "text": "high line count for integration"
      },
      {
        "regex": "\\b(?:2000|3000|4000|5000)\\+\\s+(?:lines|changes)",
        "description": "very high line counts",
        "weight": 0.5,
        "text": "massive line count"
      },
      {
        "regex": "\\b(?:weeks|months)\\s+(?:of|to)\\s+(?:development|work|implementation)",
        "description": "extended development time",
        "weight": 0.3,
        "text": "extended development time"
      },
      {
        "regex": "\\b(?:complex|complicated|sophisticated)\\s+(?:integration|setup|configuration)",
        "description": "complexity indicators for standard integrations",
        "weight": 0.2,
        "text": "complexity for standard task"
      }
    ]
  },
  "ai_doom_loop": {
    "id": "ai_doom_loop",
    "version": "1.0.0",
    "name": "AI Doom Loop and Analysis Paralysis",
    "description": "Unproductive AI conversation cycles that lead to endless analysis without concrete progress",
    "severity": "high",
    "category": "productivity",
    "detection_threshold": 0.4,
    "indicators": [
      {
        "regex": "\\b(?:should\\s+we|we\\s+need\\s+to\\s+decide|what\\s+if\\s+we)\\s+(?:use|choose|implement|go\\s+with)",
        "description": "decision paralysis language patterns",
        "weight": 0.3,
        "text": "decision paralysis"
      },
      {
        "regex": "\\b(?:on\\s+the\\s+other\\s+hand|but\\s+then\\s+again|however|alternatively)",
        "description": "cycling between options without resolution",
        "weight": 0.4,
        "text": "option cycling"
      },
      {
        "regex": "\\b(?:pros\\s+and\\s+cons|trade-?offs?|comparing|evaluating|analyzing)\\s+(?:options|approaches|alternatives)",
        "description": "endless evaluation without decision",
        "weight": 0.5,
        "text": "endless evaluation"
      },
      {
        "regex": "\\b(?:what\\s+about|maybe\\s+we\\s+should|perhaps\\s+we\\s+could|we\\s+could\\s+also)",
        "description": "continued option generation",
        "weight": 0.3,
        "text": "option multiplication"
      },
      {
        "regex": "\\b(?:edge\\s+case|corner\\s+case|what\\s+if)\\s+(?:scenario|situation|we\\s+need)",
        "description": "overthinking edge cases before core implementation",
        "weight": 0.4,
        "text": "premature edge case focus"
      },
      {
        "regex": "\\b(?:future|scale|enterprise|production)-?(?:proof|ready|grade|considerations)",
        "description": "premature optimization and over-engineering",
        "weight": 0.4,
        "text": "premature optimization"
      },
      {
        "regex": "\\b(?:best\\s+practice|industry\\s+standard|proper\\s+way|right\\s+approach)",
        "description": "perfectionist paralysis patterns",
        "weight": 0.3,
        "text": "perfectionist paralysis"
      }
    ],
    "negative_indicators": [
      {
        "regex": "\\b(?:implementing|building|shipping|deploying|testing)\\s+(?:now|today|this\\s+week)",
        "description": "concrete implementation language",
        "weight": -0.5
      },
      {
        "regex": "\\b(?:mvp|minimum\\s+viable|simplest\\s+working|prototype|proof\\s+of\\s+concept)",
        "description": "iterative development approach",
        "weight": -0.4
      },
      {
        "regex": "\\b(?:decided|chosen|picking|going\\s+with|starting\\s+with)",
        "description": "decision-making and action language",
        "weight": -0.6
      }
    ]
  },
  "analysis_paralysis": {
    "id": "analysis_paralysis",
    "version": "1.0.0", 
    "name": "Analysis Paralysis",
    "description": "Excessive analysis that prevents decision-making and implementation progress",
    "severity": "medium",
    "category": "productivity",
    "detection_threshold": 0.3,
    "indicators": [
      {
        "regex": "\\b(?:need\\s+to\\s+research|more\\s+research|further\\s+analysis|deeper\\s+investigation)",
        "description": "research instead of action",
        "weight": 0.4,
        "text": "research over action"
      },
      {
        "regex": "\\b(?:complex|complicated|sophisticated)\\s+(?:solution|approach|architecture|design)",
        "description": "complexity bias over simplicity",
        "weight": 0.3,
        "text": "complexity bias"
      },
      {
        "regex": "\\b(?:all\\s+the\\s+requirements|every\\s+possible|comprehensive\\s+solution)",
        "description": "attempting to solve everything at once",
        "weight": 0.4,
        "text": "comprehensive solution trap"
      },
      {
        "regex": "\\b(?:before\\s+we\\s+start|before\\s+implementing|first\\s+we\\s+need\\s+to\\s+figure\\s+out)",
        "description": "endless prerequisite gathering",
        "weight": 0.3,
        "text": "prerequisite paralysis"
      }
    ],
    "negative_indicators": [
      {
        "regex": "\\b(?:start\\s+simple|iterate|improve\\s+later|good\\s+enough)",
        "description": "iterative mindset",
        "weight": -0.4
      }
    ]
  }
}