diff --git a/CHANGELOG.md b/CHANGELOG.md
index a628fd3f..a85f029f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.22.0
+
+- Add analyzer for `concept/bird-watcher`
+
 ## 0.21.0
 
 - Add analyzer for `concept/elyses-analytic-enchantments`
diff --git a/package.json b/package.json
index b21a3125..63e54d46 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@exercism/javascript-analyzer",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "Exercism analyzer for javascript",
   "repository": "https://github.com/exercism/javascript-analyzer",
   "author": "Derk-Jan Karrenbeld <derk-jan+github@karrenbeld.info>",
diff --git a/src/analyzers/concept/bird-watcher/BirdWatcherSolution.ts b/src/analyzers/concept/bird-watcher/BirdWatcherSolution.ts
new file mode 100644
index 00000000..dcad526c
--- /dev/null
+++ b/src/analyzers/concept/bird-watcher/BirdWatcherSolution.ts
@@ -0,0 +1,175 @@
+import {
+  AstParser,
+  ExtractedFunction,
+  extractExports,
+  extractFunctions,
+  findFirst,
+} from '@exercism/static-analysis'
+import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/typescript-estree'
+import { readFileSync } from 'fs'
+import path from 'path'
+import { PublicApi } from '~src/analyzers/PublicApi'
+import { Source } from '~src/analyzers/SourceImpl'
+import { assertPublicApi } from '~src/asserts/assert_public_api'
+
+export const TOTAL_BIRD_COUNT = 'totalBirdCount'
+export const BIRDS_IN_WEEK = 'birdsInWeek'
+export const FIX_BIRD_COUNT_LOG = 'fixBirdCountLog'
+
+class TotalBirdCount extends PublicApi {
+  constructor(implementation: ExtractedFunction) {
+    super(implementation)
+  }
+
+  public get hasInitialTotalValue(): boolean {
+    return (
+      findFirst(
+        this.implementation.body,
+        (node): node is TSESTree.VariableDeclarator =>
+          [AST_NODE_TYPES.VariableDeclarator].some((type) => type === node.type)
+      )?.init?.value === 0
+    )
+  }
+
+  public get hasFor(): boolean {
+    return (
+      findFirst(
+        this.implementation.body,
+        (node): node is TSESTree.ForStatement =>
+          [AST_NODE_TYPES.ForStatement].some((type) => type === node.type)
+      ) !== undefined
+    )
+  }
+
+  public get usesShorthandAssignment(): boolean {
+    return (
+      findFirst(
+        this.implementation.body,
+        (node): node is TSESTree.AssignmentExpression =>
+          [AST_NODE_TYPES.AssignmentExpression].some(
+            (type) => type === node.type
+          )
+      )?.operator === '+='
+    )
+  }
+
+  public get usesIncrementalCounter(): boolean {
+    return (
+      findFirst(
+        this.implementation.body,
+        (node): node is TSESTree.UpdateExpression =>
+          [AST_NODE_TYPES.UpdateExpression].some((type) => type === node.type)
+      )?.operator === '++'
+    )
+  }
+}
+
+class BirdsInWeek extends PublicApi {
+  constructor(implementation: ExtractedFunction) {
+    super(implementation)
+  }
+  public get hasFor(): boolean {
+    return (
+      findFirst(
+        this.implementation.body,
+        (node): node is TSESTree.ForStatement =>
+          [AST_NODE_TYPES.ForStatement].some((type) => type === node.type)
+      ) !== undefined
+    )
+  }
+}
+
+class FixBirdCountLog extends PublicApi {
+  constructor(implementation: ExtractedFunction) {
+    super(implementation)
+  }
+
+  public get hasFor(): boolean {
+    return (
+      findFirst(
+        this.implementation.body,
+        (node): node is TSESTree.ForStatement =>
+          [AST_NODE_TYPES.ForStatement].some((type) => type === node.type)
+      ) !== undefined
+    )
+  }
+
+  public get usesIfStatement(): boolean {
+    return (
+      findFirst(
+        this.implementation.body,
+        (node): node is TSESTree.IfStatement =>
+          [AST_NODE_TYPES.IfStatement].some((type) => type === node.type)
+      ) !== undefined
+    )
+  }
+
+  public get usesIncrementalCounter(): boolean {
+    return (
+      findFirst(
+        this.implementation.body,
+        (node): node is TSESTree.ForStatement =>
+          [AST_NODE_TYPES.ForStatement].some((type) => type === node.type)
+      )?.body?.body[0].expression.operator === '++'
+    )
+  }
+
+  public get usesShorthandAssignment(): boolean {
+    return (
+      findFirst(
+        this.implementation.body,
+        (node): node is TSESTree.AssignmentExpression =>
+          [AST_NODE_TYPES.AssignmentExpression].some(
+            (type) => type === node.type
+          )
+      )?.operator === '+='
+    )
+  }
+}
+
+export class BirdWatcherSolution {
+  private readonly source: Source
+
+  public readonly totalBirdCount: TotalBirdCount
+  public readonly birdsInWeek: BirdsInWeek
+  public readonly fixBirdCountLog: FixBirdCountLog
+
+  private exemplar!: Source
+
+  constructor(public readonly program: TSESTree.Program, source: string) {
+    this.source = new Source(source)
+
+    const functions = extractFunctions(program)
+    const exports = extractExports(program)
+
+    this.totalBirdCount = new TotalBirdCount(
+      assertPublicApi(TOTAL_BIRD_COUNT, exports, functions)
+    )
+    this.birdsInWeek = new BirdsInWeek(
+      assertPublicApi(BIRDS_IN_WEEK, exports, functions)
+    )
+    this.fixBirdCountLog = new FixBirdCountLog(
+      assertPublicApi(FIX_BIRD_COUNT_LOG, exports, functions)
+    )
+  }
+
+  public readExemplar(directory: string): void {
+    const configPath = path.join(directory, '.meta', 'config.json')
+    const config = JSON.parse(readFileSync(configPath).toString())
+
+    const exemplarPath = path.join(directory, config.files.exemplar[0])
+    this.exemplar = new Source(readFileSync(exemplarPath).toString())
+  }
+
+  public get isExemplar(): boolean {
+    const sourceAst = AstParser.REPRESENTER.parseSync(this.source.toString())
+    const exemplarAst = AstParser.REPRESENTER.parseSync(
+      this.exemplar.toString()
+    )
+
+    return (
+      JSON.stringify(sourceAst[0].program) ===
+      JSON.stringify(exemplarAst[0].program)
+    )
+  }
+}
diff --git a/src/analyzers/concept/bird-watcher/index.ts b/src/analyzers/concept/bird-watcher/index.ts
new file mode 100644
index 00000000..6cbfc33b
--- /dev/null
+++ b/src/analyzers/concept/bird-watcher/index.ts
@@ -0,0 +1,116 @@
+import {
+  AstParser,
+  Input,
+  NoExportError,
+  NoMethodError,
+} from '@exercism/static-analysis'
+import { TSESTree } from '@typescript-eslint/typescript-estree'
+import { CommentType, factory } from '~src/comments/comment'
+import {
+  EXEMPLAR_SOLUTION,
+  NO_METHOD,
+  NO_NAMED_EXPORT,
+} from '~src/comments/shared'
+import { ExecutionOptions, WritableOutput } from '~src/interface'
+import { IsolatedAnalyzerImpl } from '~src/analyzers/IsolatedAnalyzerImpl'
+import {
+  BIRDS_IN_WEEK,
+  BirdWatcherSolution,
+  FIX_BIRD_COUNT_LOG,
+  TOTAL_BIRD_COUNT,
+} from './BirdWatcherSolution'
+
+const USE_FOR_LOOP = factory<'function'>`
+📕 The learning exercise exist to practice or demonstrate your knowledge of \`for-loops\`.
+This is different from practice exercises where you are asked to solve the best way you
+possibly can.
+
+💬 Update the function \`${'function'}\` so that it makes use of \`for-loops\`.
+
+`('javascript.bird-watcher.uses_for_loop', CommentType.Actionable)
+
+const PREFER_SHORTHAND_ASSIGNMENT = factory<'function'>`
+You can reduce some cognitive overhead when it comes to assignment in equations.
+One way to do this is using shorthand assignment that allows you to remove duplication.
+
+An example of assignment:
+
+\`\`\`javascript
+x = x + 1
+\`\`\`
+
+can be in the short hand:
+
+\`\`\`javascript
+x += 1
+\`\`\`
+
+Usage found in \`${'function'}\` if you are interested in modifying your solution.
+`(
+  'javascript.bird-watcher.prefer_shorthand_assignment',
+  CommentType.Informative
+)
+
+type Program = TSESTree.Program
+
+export class BirdWatcherAnalyzer extends IsolatedAnalyzerImpl {
+  private solution!: BirdWatcherSolution
+
+  protected async execute(
+    input: Input,
+    output: WritableOutput,
+    options: ExecutionOptions
+  ): Promise<void> {
+    const [parsed] = await AstParser.ANALYZER.parse(input)
+
+    this.solution = this.checkStructure(parsed.program, parsed.source, output)
+    this.solution.readExemplar(options.inputDir)
+
+    if (this.solution.isExemplar) {
+      output.add(EXEMPLAR_SOLUTION())
+      output.finish()
+    }
+
+    if (!this.solution.birdsInWeek.hasFor) {
+      output.add(USE_FOR_LOOP({ function: BIRDS_IN_WEEK }))
+    }
+
+    if (!this.solution.totalBirdCount.hasFor) {
+      output.add(USE_FOR_LOOP({ function: TOTAL_BIRD_COUNT }))
+    }
+    if (!this.solution.totalBirdCount.usesShorthandAssignment) {
+      output.add(PREFER_SHORTHAND_ASSIGNMENT({ function: TOTAL_BIRD_COUNT }))
+    }
+
+    if (!this.solution.fixBirdCountLog.hasFor) {
+      output.add(USE_FOR_LOOP({ function: FIX_BIRD_COUNT_LOG }))
+    }
+    if (!this.solution.fixBirdCountLog.usesShorthandAssignment) {
+      output.add(PREFER_SHORTHAND_ASSIGNMENT({ function: FIX_BIRD_COUNT_LOG }))
+    }
+
+    output.finish()
+  }
+
+  private checkStructure(
+    program: Readonly<Program>,
+    source: Readonly<string>,
+    output: WritableOutput
+  ): BirdWatcherSolution | never {
+    try {
+      return new BirdWatcherSolution(program, source)
+    } catch (error) {
+      if (error instanceof NoMethodError) {
+        output.add(NO_METHOD({ 'method.name': error.method }))
+        output.finish()
+      }
+
+      if (error instanceof NoExportError) {
+        output.add(NO_NAMED_EXPORT({ 'export.name': error.namedExport }))
+      }
+
+      throw error
+    }
+  }
+}
+export default BirdWatcherAnalyzer
diff --git a/test/analyzers/bird-watcher/exemplar.ts b/test/analyzers/bird-watcher/exemplar.ts
new file mode 100644
index 00000000..d7b7fba4
--- /dev/null
+++ b/test/analyzers/bird-watcher/exemplar.ts
@@ -0,0 +1,41 @@
+import { DirectoryWithConfigInput } from '@exercism/static-analysis'
+import path from 'path'
+import { BirdWatcherAnalyzer } from '~src/analyzers/concept/bird-watcher'
+import { EXEMPLAR_SOLUTION } from '~src/comments/shared'
+import { makeAnalyze, makeOptions } from '~test/helpers/smoke'
+
+const inputDir = path.join(
+  __dirname,
+  '..',
+  '..',
+  'fixtures',
+  'bird-watcher',
+  'exemplar'
+)
+
+const analyze = makeAnalyze(
+  () => new BirdWatcherAnalyzer(),
+  makeOptions({
+    get inputDir(): string {
+      return inputDir
+    },
+    get exercise(): string {
+      return 'bird-watcher'
+    },
+  })
+)
+
+describe('When running analysis on bird-watcher', () => {
+  it('recognizes the exemplar solution', async () => {
+    const input = new DirectoryWithConfigInput(inputDir)
+
+    const [solution] = await input.read()
+    const output = await analyze(solution)
+
+    expect(output.comments.length).toBe(1)
+    expect(output.comments[0].type).toBe('celebratory')
+    expect(output.comments[0].externalTemplate).toBe(
+      EXEMPLAR_SOLUTION().externalTemplate
+    )
+  })
+})
diff --git a/test/fixtures/bird-watcher/uses-if/.meta/config.json b/test/fixtures/bird-watcher/uses-if/.meta/config.json
new file mode 100644
index 00000000..ec8c67c2
--- /dev/null
+++ b/test/fixtures/bird-watcher/uses-if/.meta/config.json
@@ -0,0 +1,11 @@
+{
+  "blurb": "Professionalize counting the birds in your garden with for loops and increment/decrement operators",
+  "authors": ["junedev"],
+  "contributors": [],
+  "files": {
+    "solution": ["bird-watcher.js"],
+    "test": ["bird-watcher.spec.js"],
+    "exemplar": [".meta/exemplar.js"]
+  },
+  "forked_from": ["csharp/bird-watcher"]
+}
diff --git a/test/fixtures/bird-watcher/uses-if/.meta/exemplar.js b/test/fixtures/bird-watcher/uses-if/.meta/exemplar.js
new file mode 100644
index 00000000..616b6c88
--- /dev/null
+++ b/test/fixtures/bird-watcher/uses-if/.meta/exemplar.js
@@ -0,0 +1,49 @@
+// @ts-check
+//
+// The line above enables type checking for this file. Various IDEs interpret
+// the @ts-check directive. It will give you helpful autocompletion when
+// implementing this exercise.
+
+/**
+ * Calculates the total bird count.
+ *
+ * @param {number[]} birdsPerDay
+ * @returns {number} total bird count
+ */
+export function totalBirdCount(birdsPerDay) {
+  let total = 0;
+  for (let i = 0; i < birdsPerDay.length; i++) {
+    total += birdsPerDay[i];
+  }
+  return total;
+}
+
+/**
+ * Calculates the total number of birds seen in a specific week.
+ *
+ * @param {number[]} birdsPerDay
+ * @param {number} week
+ * @returns {number} birds counted in the given week
+ */
+export function birdsInWeek(birdsPerDay, week) {
+  let total = 0;
+  const start = 7 * (week - 1);
+  for (let i = start; i < start + 7; i++) {
+    total += birdsPerDay[i];
+  }
+  return total;
+}
+
+/**
+ * Fixes the counting mistake by increasing the bird count
+ * by one for every second day.
+ *
+ * @param {number[]} birdsPerDay
+ * @returns {number[]} corrected bird count data
+ */
+export function fixBirdCountLog(birdsPerDay) {
+  for (let i = 0; i < birdsPerDay.length; i += 2) {
+    birdsPerDay[i]++;
+  }
+  return birdsPerDay;
+}
diff --git a/test/fixtures/bird-watcher/uses-if/bird-watcher.js b/test/fixtures/bird-watcher/uses-if/bird-watcher.js
new file mode 100644
index 00000000..a22f69bb
--- /dev/null
+++ b/test/fixtures/bird-watcher/uses-if/bird-watcher.js
@@ -0,0 +1,50 @@
+// @ts-check
+//
+// The line above enables type checking for this file. Various IDEs interpret
+// the @ts-check directive. It will give you helpful autocompletion when
+// implementing this exercise.
+
+/**
+ * Calculates the total bird count.
+ *
+ * @param {number[]} birdsPerDay
+ * @returns {number} total bird count
+ */
+export function totalBirdCount(birdsPerDay) {
+  let total = 0;
+  for (let i = 0; i < birdsPerDay.length; i++) {
+    total += birdsPerDay[i];
+  }
+  return total;
+}
+
+/**
+ * Calculates the total number of birds seen in a specific week.
+ *
+ * @param {number[]} birdsPerDay
+ * @param {number} week
+ * @returns {number} birds counted in the given week
+ */
+export function birdsInWeek(birdsPerDay, week) {
+  let total = 0;
+  const start = 7 * (week - 1);
+  for (let i = start; i < start + 7; i++) {
+    total += birdsPerDay[i];
+  }
+  return total;
+}
+
+/**
+ * Fixes the counting mistake by increasing the bird count
+ * by one for every second day.
+ *
+ * @param {number[]} birdsPerDay
+ * @returns {number[]} corrected bird count data
+ */
+export function fixBirdCountLog(birdsPerDay) {
+  if (birdsPerDay) {return}
+  for (let i = 0; i < birdsPerDay.length; i += 2) {
+    birdsPerDay[i]++;
+  }
+  return birdsPerDay;
+}
diff --git a/test/fixtures/bird-watcher/uses-if/bird-watcher.spec.js b/test/fixtures/bird-watcher/uses-if/bird-watcher.spec.js
new file mode 100644
index 00000000..3339045c
--- /dev/null
+++ b/test/fixtures/bird-watcher/uses-if/bird-watcher.spec.js
@@ -0,0 +1,80 @@
+import { totalBirdCount, birdsInWeek, fixBirdCountLog } from './bird-watcher';
+
+describe('bird watcher', () => {
+  describe('totalBirdCount', () => {
+    test('calculates the correct total number of birds', () => {
+      const birdsPerDay = [9, 0, 8, 4, 5, 1, 3];
+      expect(totalBirdCount(birdsPerDay)).toBe(30);
+    });
+
+    test('works for a short bird count list', () => {
+      const birdsPerDay = [2];
+      expect(totalBirdCount(birdsPerDay)).toBe(2);
+    });
+
+    test('works for a long bird count list', () => {
+      // prettier-ignore
+      const birdsPerDay = [2, 8, 4, 1, 3, 5, 0, 4, 1, 6, 0, 3, 0, 1, 5, 4, 1, 1, 2, 6];
+      expect(totalBirdCount(birdsPerDay)).toBe(57);
+    });
+  });
+
+  describe('birdsInWeek', () => {
+    test('calculates the number of birds in the first week', () => {
+      const birdsPerDay = [3, 0, 5, 1, 0, 4, 1, 0, 3, 4, 3, 0, 8, 0];
+      expect(birdsInWeek(birdsPerDay, 1)).toBe(14);
+    });
+
+    test('calculates the number of birds for a week in the middle of the log', () => {
+      // prettier-ignore
+      const birdsPerDay = [4, 7, 3, 2, 1, 1, 2, 0, 2, 3, 2, 7, 1, 3, 0, 6, 5, 3, 7, 2, 3];
+      expect(birdsInWeek(birdsPerDay, 2)).toBe(18);
+    });
+
+    test('works when there is only one week', () => {
+      const birdsPerDay = [3, 0, 3, 3, 2, 1, 0];
+      expect(birdsInWeek(birdsPerDay, 1)).toBe(12);
+    });
+
+    test('works for a long bird count list', () => {
+      const week21 = [2, 0, 1, 4, 1, 3, 0];
+      const birdsPerDay = randomArray(20 * 7)
+        .concat(week21)
+        .concat(randomArray(10 * 7));
+
+      expect(birdsInWeek(birdsPerDay, 21)).toBe(11);
+    });
+  });
+
+  describe('fixBirdCountLog', () => {
+    test('returns a bird count list with the corrected values', () => {
+      const birdsPerDay = [3, 0, 5, 1, 0, 4, 1, 0, 3, 4, 3, 0];
+      const expected = [4, 0, 6, 1, 1, 4, 2, 0, 4, 4, 4, 0];
+      expect(fixBirdCountLog(birdsPerDay)).toEqual(expected);
+    });
+
+    test('does not create a new array', () => {
+      const birdsPerDay = [2, 0, 1, 4, 1, 3, 0];
+
+      // this follows the suggestion from the Jest docs to avoid a confusing test report
+      // https://jestjs.io/docs/expect#tobevalue
+      expect(Object.is(fixBirdCountLog(birdsPerDay), birdsPerDay)).toBe(true);
+    });
+
+    test('works for a short bird count list', () => {
+      expect(fixBirdCountLog([4, 2])).toEqual([5, 2]);
+    });
+
+    test('works for a long bird count list', () => {
+      // prettier-ignore
+      const birdsPerDay = [2, 8, 4, 1, 3, 5, 0, 4, 1, 6, 0, 3, 0, 1, 5, 4, 1, 1, 2, 6];
+      // prettier-ignore
+      const expected = [3, 8, 5, 1, 4, 5, 1, 4, 2, 6, 1, 3, 1, 1, 6, 4, 2, 1, 3, 6];
+      expect(fixBirdCountLog(birdsPerDay)).toEqual(expected);
+    });
+  });
+});
+
+function randomArray(length) {
+  return Array.from({ length: length }, () => Math.floor(Math.random() * 8));
+}