diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 632f36c9..132503c0 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -36,23 +36,34 @@ jobs:
 
       - name: Run markdown lint
         run: ./bin/lint_markdown.sh
-        
+
+  # stolen from https://raw.githubusercontent.com/exercism/github-actions/main/.github/workflows/shellcheck.yml
+  shellcheck:
+    name: Run shellcheck on scripts
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+
+      - name: Run shellcheck
+        uses: ludeeus/action-shellcheck@00cae500b08a931fb5698e11e79bfbd38e612a38
+
   build:
     name: Check build
     runs-on: ubuntu-22.04
-    
+
     steps:
       - name: Checkout code
         uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
-        
+
       - name: Fetch origin/main
         run: git fetch --depth=1 origin main
-      
+
       - name: Getting scarb
         uses: software-mansion/setup-scarb@v1
         with:
           scarb-version: "2.6.3"
-          
+
       - name: Verify all exercises
         env:
           DENYWARNINGS: "1"
@@ -61,11 +72,11 @@ jobs:
   format:
     name: Check Cairo formatting
     runs-on: ubuntu-22.04
-    
+
     steps:
       - name: Checkout code
         uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
-      
+
       - name: Getting scarb
         uses: software-mansion/setup-scarb@v1
         with:
diff --git a/bin/format_exercises.sh b/bin/format_exercises.sh
index 8720c82a..94c65d43 100755
--- a/bin/format_exercises.sh
+++ b/bin/format_exercises.sh
@@ -8,32 +8,42 @@ repo=$(git rev-parse --show-toplevel)
 # traverse either concept or practice exercise
 # directory and format Cairo files
 format_exercises() {
-    exercises_path="$repo/exercises/$1"
+    exercises_path="$repo/exercises/$1/*"
     source_file_name="$2"
-    for exercise_dir in "$exercises_path"/*; do
-        cd "$exercise_dir"
+
+    for exercise_dir in $exercises_path; do
+        cd "$exercise_dir" || exit 1
+
+        exercise=$(basename "$exercise_dir")
+        
+        # scarb fmt cannot currently format individual files, so we have to
+        # temporarily move the solution files into the Cairo package, where
+        # 'scarb fmt' can format it as well
+        tmp_file=$(mktemp "./src/tmp.XXXXXXXXXXX.cairo")
+
         config_file="$exercise_dir/.meta/config.json"
         if jq --exit-status '.custom?."allowed-to-not-compile"?' "$config_file"; then
-            exercise=$(basename "$exercise_dir")
             echo "$exercise's stub is allowed to not compile"
             # exit the subshell successfully to continue
             # to the next exercise directory
             exit 0
         fi
-        # scarb fmt cannot currently format individual files, so we have to
-        # temporarily move the solution files into the Cairo package, where
-        # 'scarb fmt' can format it as well
-        tmp_file=$(mktemp "./src/tmp.XXXXXXXXXXX.cairo")
-        file_name=".meta/$source_file_name.cairo"
-        if [ -f "$file_name" ]; then
-            cp "$file_name" "$tmp_file"
+
+        solution_file=".meta/$source_file_name.cairo"
+        if [ -z "$solution_file" ]; then
+            echo "Could not find solution file for $exercise"
+            exit 1
         fi
+
+        # move the solution file into the package       
+        cp "$solution_file" "$tmp_file"
+
         scarb fmt
+
         # move the solution file back
-        if [ -f "$file_name" ]; then
-            cp "$tmp_file" "$file_name"
-        fi
-        rm $tmp_file
+        cp "$tmp_file" "$solution_file"
+        
+        rm "$tmp_file"
     done
 }
 
diff --git a/bin/lint_markdown.sh b/bin/lint_markdown.sh
index e6be7aa5..278d2c7e 100755
--- a/bin/lint_markdown.sh
+++ b/bin/lint_markdown.sh
@@ -1,10 +1,7 @@
 #!/usr/bin/env bash
 set -eo pipefail
 
-markdownlint_cli_args="$1"
-
 npx markdownlint-cli2 \
-    $markdownlint_cli_args \
     docs/*.md \
     concepts/**/*.md \
     exercises/**/*.md
diff --git a/bin/verify-exercises b/bin/verify-exercises
index 936db1cc..0d7d0898 100755
--- a/bin/verify-exercises
+++ b/bin/verify-exercises
@@ -2,18 +2,6 @@
 
 # Synopsis:
 # Test the track's exercises.
-# 
-# At a minimum, this file must check if the example/exemplar solution of each 
-# Practice/Concept Exercise passes the exercise's tests.
-#
-# To check this, you usually have to (temporarily) replace the exercise's solution files
-# with its exemplar/example files.
-#
-# If your track uses skipped tests, make sure to (temporarily) enable these tests
-# before running the tests.
-#
-# The path to the solution/example/exemplar files can be found in the exercise's
-# .meta/config.json file, or possibly inferred from the exercise's directory name.
 
 # Example: verify all exercises
 # ./bin/verify-exercises
@@ -25,38 +13,39 @@ repo=$(git rev-parse --show-toplevel)
 
 lib_cairo="./src/lib.cairo"
 
+slug="${1:-*}"
+
 verify_exercise() {
-    exercises_path="$repo/exercises/$1"
+    exercises_path="$repo/exercises/$1/$slug"
     source_file_name="$2"
     tmp_file=$(mktemp)
-    
-    for exercise_dir in "$exercises_path"/*; do
-        if [ -z $exercise_dir ]; then
+    trap 'rm $tmp_file' EXIT INT TERM
+
+    for exercise_dir in $exercises_path; do
+        if [ -z "$exercise_dir" ]; then
             continue
         fi
-        
-        slug=$(basename "$exercise_dir")
-        echo "Checking $slug exercise..."
-        
-        cd "$exercise_dir"
-        
+
+        exercise=$(basename "$exercise_dir")
+        echo "Checking $exercise exercise..."
+
+        cd "$exercise_dir" || exit 1
+
         solution_file=".meta/$source_file_name.cairo"
         if [ -z "$solution_file" ]; then
-            echo "Could not find solution for $1"
+            echo "Could not find solution file for $exercise"
             exit 1
         fi
-        
+
         # since we're testing the solution, we need to temporarily replace
         # the exercise's solution files with its exemplar/example files
         cp "$lib_cairo" "$tmp_file"
         cp "$solution_file" "$lib_cairo"
-        
+
         scarb cairo-test
-        
+
         cp "$tmp_file" "$lib_cairo"
     done
-    
-    rm $tmp_file
 }
 
 # https://github.com/exercism/docs/blob/main/anatomy/tracks/concept-exercises.md#file-exemplar-implementation
diff --git a/config.json b/config.json
index fd6c9669..aa9eeec6 100644
--- a/config.json
+++ b/config.json
@@ -77,6 +77,16 @@
         ],
         "prerequisites": [],
         "difficulty": 1
+      },
+      {
+        "slug": "lucians-luscious-lasagna",
+        "name": "lucians-luscious-lasagna",
+        "uuid": "8302f8de-14d7-45dd-9a65-812bc1ed5464",
+        "practices": [
+          "functions"
+        ],
+        "prerequisites": [],
+        "difficulty": 1
       }
     ]
   },
diff --git a/docs/ABOUT.md b/docs/ABOUT.md
index c12f6b41..eacb151c 100644
--- a/docs/ABOUT.md
+++ b/docs/ABOUT.md
@@ -6,6 +6,7 @@ scalable [dApps][dapps] with the power of [validity proofs][zkp].
 [cairo]: https://www.cairo-lang.org/
 [dapps]: https://en.wikipedia.org/wiki/Decentralized_application
 [zkp]: https://en.wikipedia.org/wiki/Zero-knowledge_proof
+
 <!-- TODO: write document
 
   This document contains a short introduction to the language.
diff --git a/exercises/practice/armstrong-numbers/.docs/instructions.md b/exercises/practice/armstrong-numbers/.docs/instructions.md
index f519578b..1820ebcf 100644
--- a/exercises/practice/armstrong-numbers/.docs/instructions.md
+++ b/exercises/practice/armstrong-numbers/.docs/instructions.md
@@ -9,7 +9,7 @@ For example:
 - 10 is _not_ an Armstrong number, because `10 != 1^2 + 0^2 = 1`
 - 153 is an Armstrong number, because: `153 = 1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153`
 - 154 is _not_ an Armstrong number, because:
-`154 != 1^3 + 5^3 + 4^3 = 1 + 125 + 64 = 190`
+  `154 != 1^3 + 5^3 + 4^3 = 1 + 125 + 64 = 190`
 
 Write some code to determine whether a number is an Armstrong number.
 
diff --git a/exercises/practice/leap/.docs/introduction.md b/exercises/practice/leap/.docs/introduction.md
index 21f2e97b..739363db 100644
--- a/exercises/practice/leap/.docs/introduction.md
+++ b/exercises/practice/leap/.docs/introduction.md
@@ -4,7 +4,7 @@ A leap year (in the Gregorian calendar) occurs:
 
 - In every year that is evenly divisible by 4.
 - Unless the year is evenly divisible by 100, in which case it's only a leap
-year if the year is also evenly divisible by 400.
+  year if the year is also evenly divisible by 400.
 
 Some examples:
 
@@ -13,6 +13,6 @@ Some examples:
 - 2000 was a leap year!
 
 > For a delightful, four-minute explanation of the whole phenomenon of leap
-years, check out [this YouTube video][video].
+> years, check out [this YouTube video][video].
 
 [video]: https://www.youtube.com/watch?v=xX96xng7sAE
diff --git a/exercises/practice/lucians-luscious-lasagna/.docs/hints.md b/exercises/practice/lucians-luscious-lasagna/.docs/hints.md
new file mode 100644
index 00000000..c660140b
--- /dev/null
+++ b/exercises/practice/lucians-luscious-lasagna/.docs/hints.md
@@ -0,0 +1,37 @@
+# Hints
+
+## General
+
+- An integer literal can be defined as one or more consecutive digits.
+
+## 1. Define the expected oven time in minutes
+
+- You need to define a [function][functions] without any parameters.
+
+## 2. Calculate the remaining oven time in minutes
+
+- You need to define a [function][functions] with a single parameter.
+- You can use and refer to the previously defined item by its name.
+- The last expression in a function is [automatically returned][return-values]
+  from the function; you don't have to explicitly indicate which value to
+  return.
+- You can use the [mathematical operator for subtraction][operators] to
+  subtract values.
+
+## 3. Calculate the preparation time in minutes
+
+- You need to define a [function][functions] with a single parameter.
+- You can use the [mathematical operator for multiplication][operators] to
+  multiply values.
+
+## 4. Calculate the elapsed time in minutes
+
+- You need to define a [function][functions] with two parameters.
+- You can [call][functions] one of the other functions you've defined
+  previously.
+- You can use the [mathematical operator for addition][operators] to add
+  values.
+
+[functions]: https://book.cairo-lang.org/ch02-03-functions.html
+[return-values]: https://book.cairo-lang.org/ch02-03-functions.html#functions-with-return-values
+[operators]: https://book.cairo-lang.org/appendix-02-operators-and-symbols.html
diff --git a/exercises/practice/lucians-luscious-lasagna/.docs/instructions.md b/exercises/practice/lucians-luscious-lasagna/.docs/instructions.md
new file mode 100644
index 00000000..0068e266
--- /dev/null
+++ b/exercises/practice/lucians-luscious-lasagna/.docs/instructions.md
@@ -0,0 +1,55 @@
+# Instructions
+
+In this exercise you're going to write some code to help you cook a brilliant
+lasagna from your favorite cooking book.
+
+You have four tasks, all related to the time spent cooking the lasagna.
+
+## 1. Define the expected oven time in minutes
+
+Define the `expected_minutes_in_oven` binding to check how many minutes the
+lasagna should be in the oven. According to the cooking book, the expected
+oven time in minutes is 40:
+
+```rust
+expected_minutes_in_oven()
+// Returns: 40
+```
+
+## 2. Calculate the remaining oven time in minutes
+
+Define the `remaining_minutes_in_oven` function that takes the actual minutes
+the lasagna has been in the oven as a parameter and returns how many minutes
+the lasagna still has to remain in the oven, based on the expected oven time
+in minutes from the previous task.
+
+```rust
+remaining_minutes_in_oven(30)
+// Returns: 10
+```
+
+## 3. Calculate the preparation time in minutes
+
+Define the `preparation_time_in_minutes` function that takes the number of
+layers you added to the lasagna as a parameter and returns how many minutes you
+spent preparing the lasagna, assuming each layer takes you 2 minutes to
+prepare.
+
+```rust
+preparation_time_in_minutes(2)
+// Returns: 4
+```
+
+## 4. Calculate the elapsed time in minutes
+
+Define the `elapsed_time_in_minutes` function that takes two parameters: the
+first parameter is the number of layers you added to the lasagna, and the
+second parameter is the number of minutes the lasagna has been in the oven.
+The function should return how many minutes you've worked on cooking the
+lasagna, which is the sum of the preparation time in minutes, and the time in
+minutes the lasagna has spent in the oven at the moment.
+
+```rust
+elapsed_time_in_minutes(3, 20)
+// Returns: 26
+```
diff --git a/exercises/practice/lucians-luscious-lasagna/.docs/introduction.md b/exercises/practice/lucians-luscious-lasagna/.docs/introduction.md
new file mode 100644
index 00000000..a6f13d1a
--- /dev/null
+++ b/exercises/practice/lucians-luscious-lasagna/.docs/introduction.md
@@ -0,0 +1,134 @@
+# Introduction
+
+In Cairo, assigning a value to a name is referred to as a _binding_. Bindings
+are immutable unless declared with the `mut` keyword. As Cairo is a
+statically-typed language, each binding has a type known at compile-time.
+
+Bindings are most commonly defined using the `let` keyword. Specifying a
+binding's type is optional for most bindings, as Cairo's _type inference_
+can usually infer the type based on their value. A binding looks like this:
+
+```rust
+// Automatically inferred type
+let fingers = 10;
+```
+
+Functions are _items_. Where bindings typically refer to a particular value,
+items refer to a unit of code organization, typically a function or a module,
+which is available throughout the lifetime of the program. A function
+automatically returns the result of its last expression. A function may have 0
+or more parameters, which are bindings with a lifetime of the function call.
+
+Type inference is theoretically possible for functions, but is disabled as an
+intentional language design choice. While this means that you need to spend a
+little more time when writing code to specify precisely what a function's input
+and output types are, you save the time when you're reading the code, because
+all the input and output types are explicitly defined.
+
+```rust
+fn add(x: i32, y: i32) -> i32 {
+  x + y
+}
+```
+
+Invoking a function is done by specifying its name followed by parentheses.
+If the function requires parameters, an argument must be specified for each
+within the parentheses.
+
+```rust
+let five = add(2, 3);
+```
+
+If a binding's type cannot be inferred, the compiler will report an error. To
+fix this, add an explicit type annotation to the binding.
+
+```rust
+// Explicit type annotation
+let fingers: i32 = 10;
+```
+
+Items in Cairo can be used before or after they are defined, because they have
+a static lifetime. Bindings, on the other hand, can only be used _after_ they
+have been defined. Using a binding before it has been defined results in a
+compile error.
+
+```rust
+fn main() {
+    // `fn add` hasn't yet been defined, but that's perfectly ok
+    dbg!(add(3, 4));
+}
+
+fn add(x: i32, y: i32) -> i32 {
+  x + y
+}
+```
+
+```rust
+// this won't compile; `a` is used before its binding is defined
+let b = a;
+let a = x + y;
+```
+
+Cairo uses curly braces (`{}`) to define a scope. A binding defined within a
+scope can't escape from it.
+
+```rust
+let a = 1;
+dbg!(a); // 1
+{
+    // Here, we re-bind `a` to a new value, which is still immutable.
+    // This technique is called _shadowing_. The new binding is constrained to
+    // this anonymous scope. Outside this scope, the previous binding still
+    // applies.
+    let a = 2;
+    let b = 3;
+    dbg!(a, b); // 2, 3
+}
+// can't use `b` anymore because it is out of scope
+// dbg!(b);
+
+// The shadowed `a` in the inner scope above has fallen out of scope,
+// leaving us with our original binding.
+dbg!(a); // 1
+```
+
+Cairo items are often organized in modules. Each crate is implicitly a module,
+but it can define inner sub-modules of arbitrary depth. A module groups related
+functionality and is defined using the `mod` keyword.
+
+```rust
+mod calc_i32 {
+    fn add(a: i32, b: i32) -> i32 { a + b }
+    fn sub(a: i32, b: i32) -> i32 { a - b }
+    fn mul(a: i32, b: i32) -> i32 { a * b }
+    fn div(a: i32, b: i32) -> i32 { a / b }
+}
+```
+
+Cairo supports two types of comments. The keyword `//` indicates a single-line
+comment; everything following the keyword until the end of the line is ignored.
+The keywords `/*` and `*/` indicate a multi-line comment; everything within
+those two keywords is ignored. It is idiomatic and good practice to prefer
+single-line comments.
+
+Cairo also supports doc-comments, which show up in the generated documentation
+produced by `cargo doc`. Outer doc comments are formed with the keyword `///`,
+which acts identically to the `//` keyword. They apply to the item which
+follows them, such as a function:
+
+```rust
+/// The `add` function produces the sum of its arguments.
+fn add(x: i32, y: i32) -> i32 { x + y }
+```
+
+Inner doc comments are formed with the keyword `//!`, which acts identically to
+the `//` keyword. They apply to the item enclosing them, such as a module:
+
+```rust
+mod my_cool_module {
+    //! This module is the bee's knees.
+}
+```
+
+Doc comments can be of arbitrary length and contain markdown, which is rendered
+into the generated documentation.
diff --git a/exercises/practice/lucians-luscious-lasagna/.meta/config.json b/exercises/practice/lucians-luscious-lasagna/.meta/config.json
new file mode 100644
index 00000000..3252f418
--- /dev/null
+++ b/exercises/practice/lucians-luscious-lasagna/.meta/config.json
@@ -0,0 +1,19 @@
+{
+  "authors": [
+    "misicnenad"
+  ],
+  "files": {
+    "solution": [
+      "src/lib.cairo",
+      "Scarb.toml"
+    ],
+    "test": [
+      "src/tests.cairo"
+    ],
+    "example": [
+      ".meta/example.cairo"
+    ]
+  },
+  "icon": "lasagna",
+  "blurb": "Learn about the basics of Cairo by following a lasagna recipe."
+}
diff --git a/exercises/practice/lucians-luscious-lasagna/.meta/design.md b/exercises/practice/lucians-luscious-lasagna/.meta/design.md
new file mode 100644
index 00000000..5edb8a76
--- /dev/null
+++ b/exercises/practice/lucians-luscious-lasagna/.meta/design.md
@@ -0,0 +1,37 @@
+# Design
+
+## Learning objectives
+
+- Know how to define a function
+- Know how to return a value from a function
+
+## Out of scope
+
+- Know how to work with `const` values
+
+## Concepts
+
+- Functions
+
+## Prerequisites
+
+None
+
+## Resources to refer to
+
+### Hints
+
+- [Functions](https://book.cairo-lang.org/ch02-03-functions.html)
+- [Return values](https://book.cairo-lang.org/ch02-03-functions.html#functions-with-return-values)
+- [Operators](https://book.cairo-lang.org/appendix-02-operators-and-symbols.html)
+
+### After
+
+## Representer
+
+This exercise does not require any specific representation logic to be added to
+the representer.
+
+## Analyzer
+
+This exercise does not require any specific logic to be added to the analyzer.
diff --git a/exercises/practice/lucians-luscious-lasagna/.meta/example.cairo b/exercises/practice/lucians-luscious-lasagna/.meta/example.cairo
new file mode 100644
index 00000000..d85502ed
--- /dev/null
+++ b/exercises/practice/lucians-luscious-lasagna/.meta/example.cairo
@@ -0,0 +1,18 @@
+pub fn expected_minutes_in_oven() -> u32 {
+    40
+}
+
+pub fn remaining_minutes_in_oven(actual_minutes_in_oven: u32) -> u32 {
+    expected_minutes_in_oven() - actual_minutes_in_oven
+}
+
+pub fn preparation_time_in_minutes(number_of_layers: u32) -> u32 {
+    number_of_layers * 2
+}
+
+pub fn elapsed_time_in_minutes(number_of_layers: u32, actual_minutes_in_oven: u32) -> u32 {
+    preparation_time_in_minutes(number_of_layers) + actual_minutes_in_oven
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/exercises/practice/lucians-luscious-lasagna/Scarb.toml b/exercises/practice/lucians-luscious-lasagna/Scarb.toml
new file mode 100644
index 00000000..88827db0
--- /dev/null
+++ b/exercises/practice/lucians-luscious-lasagna/Scarb.toml
@@ -0,0 +1,4 @@
+[package]
+name = "lucians_luscious_lasagna"
+version = "0.1.0"
+edition = "2023_11"
diff --git a/exercises/practice/lucians-luscious-lasagna/src/lib.cairo b/exercises/practice/lucians-luscious-lasagna/src/lib.cairo
new file mode 100644
index 00000000..e0577240
--- /dev/null
+++ b/exercises/practice/lucians-luscious-lasagna/src/lib.cairo
@@ -0,0 +1,22 @@
+pub fn expected_minutes_in_oven() -> u32 {
+    panic!("return expected minutes in the oven")
+}
+
+pub fn remaining_minutes_in_oven(actual_minutes_in_oven: u32) -> u32 {
+    panic!(
+        "calculate remaining minutes in oven given actual minutes in oven: {actual_minutes_in_oven}"
+    )
+}
+
+pub fn preparation_time_in_minutes(number_of_layers: u32) -> u32 {
+    panic!("calculate preparation time in minutes for number of layers: {number_of_layers}")
+}
+
+pub fn elapsed_time_in_minutes(number_of_layers: u32, actual_minutes_in_oven: u32) -> u32 {
+    panic!(
+        "calculate elapsed time in minutes for number of layers {number_of_layers} and actual minutes in oven {actual_minutes_in_oven}"
+    )
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/exercises/practice/lucians-luscious-lasagna/src/tests.cairo b/exercises/practice/lucians-luscious-lasagna/src/tests.cairo
new file mode 100644
index 00000000..3733f035
--- /dev/null
+++ b/exercises/practice/lucians-luscious-lasagna/src/tests.cairo
@@ -0,0 +1,34 @@
+use lucians_luscious_lasagna::{
+    elapsed_time_in_minutes, expected_minutes_in_oven, preparation_time_in_minutes,
+    remaining_minutes_in_oven
+};
+
+#[test]
+fn expected_minutes_in_oven_is_correct() {
+    assert_eq!(40, expected_minutes_in_oven());
+}
+
+#[test]
+fn remaining_minutes_in_oven_after_fifteen_minutes() {
+    assert_eq!(15, remaining_minutes_in_oven(25));
+}
+
+#[test]
+fn preparation_time_in_minutes_for_one_layer() {
+    assert_eq!(2, preparation_time_in_minutes(1));
+}
+
+#[test]
+fn preparation_time_in_minutes_for_multiple_layers() {
+    assert_eq!(8, preparation_time_in_minutes(4));
+}
+
+#[test]
+fn elapsed_time_in_minutes_for_one_layer() {
+    assert_eq!(32, elapsed_time_in_minutes(1, 30));
+}
+
+#[test]
+fn elapsed_time_in_minutes_for_multiple_layers() {
+    assert_eq!(16, elapsed_time_in_minutes(4, 8));
+}
diff --git a/exercises/practice/semi-structured-logs/.docs/hints.md b/exercises/practice/semi-structured-logs/.docs/hints.md
index 7707c559..d50064c0 100644
--- a/exercises/practice/semi-structured-logs/.docs/hints.md
+++ b/exercises/practice/semi-structured-logs/.docs/hints.md
@@ -8,7 +8,7 @@
 ## 1. Emit semi-structured messages
 
 - `match` comes in handy when working with enums. In this case, see how you
-might use it when figuring how what kind of log message to generate.
+  might use it when figuring how what kind of log message to generate.
 
 [tcb-enums]: https://book.cairo-lang.org/ch06-01-enums.html
 [tcb-match]: https://book.cairo-lang.org/ch06-02-the-match-control-flow-construct.html