diff --git a/Cargo.toml b/Cargo.toml
index 48fa22e..0ca0221 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,9 +18,8 @@ heck = "0.5"
 term = "1"
 toml = "0.8"
 walkdir = "2"
-
-[dev-dependencies]
 tempfile = "3"
 
+
 [badges]
 maintenance = {status = "actively-developed"}
diff --git a/README.md b/README.md
index 809829e..2ad6e96 100644
--- a/README.md
+++ b/README.md
@@ -111,6 +111,25 @@ cleanup = [
     { name = "auth_method", value = "none", paths = ["{{ project_name }}/docs/auth.md"]},
 ]
 
+# A list of hooks we can run at various stages of the template.
+# This will execute the given files in the given order and they will be templated with access to all the variables.
+# Hooks can also be run conditionally depending on a variable value.
+# If a hook is meant to fail, make sure to exit with a non 0 error code.
+# The files need to be executable, no restrictions otherwise. It can be python, bash, bat etc.
+
+# pre-gen hooks are run after all the questions have been answered. This can be used for example to do more complex
+# validations
+pre_gen_hooks = [
+    { name = "validate", path = "validate_vars.py" },
+]
+
+# post-gen hooks are run after the generation is done. This can be used for additional cleanup or running other things
+# like `git init`, install git hooks, downloading dependencies etc
+post_gen_hooks = [
+    { name = "finish setup", path = "finish_setup.sh" },
+    { name = "install frontend dependencies", path = "install_spa_deps.sh", only_if = { name = "spa", value = true} },
+]
+
 # A list of variables, the schema is explained in detail below
 [[variables]]
 name = "project_name"
diff --git a/src/bin/kickstart.rs b/src/bin/kickstart.rs
index 7d7cd37..5303d49 100644
--- a/src/bin/kickstart.rs
+++ b/src/bin/kickstart.rs
@@ -1,11 +1,18 @@
+use std::collections::HashMap;
 use std::error::Error;
 use std::path::PathBuf;
 
 use clap::{Parser, Subcommand};
+use tera::Context;
+use toml::Value;
 
-use kickstart::generation::Template;
-use kickstart::terminal;
-use kickstart::validate::validate_file;
+use kickstart::errors::{new_error, ErrorKind, Result};
+use kickstart::prompt::{ask_bool, ask_choices, ask_integer, ask_string};
+use kickstart::utils::render_one_off_template;
+use kickstart::validate_file;
+use kickstart::Template;
+use kickstart::TemplateDefinition;
+use kickstart::{terminal, HookFile};
 
 #[derive(Parser)]
 #[clap(version, author, about, subcommand_negates_reqs = true)]
@@ -41,44 +48,142 @@ pub enum Command {
     },
 }
 
+/// Ask all the questions of that template and return the answers.
+/// If `no_input` is `true`, it will automatically pick the defaults without
+/// prompting the user
+fn ask_questions(
+    definition: &TemplateDefinition,
+    no_input: bool,
+) -> Result<HashMap<String, Value>> {
+    let mut vals = HashMap::new();
+
+    for var in &definition.variables {
+        // Skip the question if the value is different from the condition
+        if let Some(ref cond) = var.only_if {
+            if let Some(val) = vals.get(&cond.name) {
+                if *val != cond.value {
+                    continue;
+                }
+            } else {
+                // Not having it means we didn't even ask the question
+                continue;
+            }
+        }
+
+        if let Some(ref choices) = var.choices {
+            let res = if no_input {
+                var.default.clone()
+            } else {
+                ask_choices(&var.prompt, &var.default, choices)?
+            };
+            vals.insert(var.name.clone(), res);
+            continue;
+        }
+
+        match &var.default {
+            Value::Boolean(b) => {
+                let res = if no_input { *b } else { ask_bool(&var.prompt, *b)? };
+                vals.insert(var.name.clone(), Value::Boolean(res));
+                continue;
+            }
+            Value::String(s) => {
+                let default_value = if s.contains("{{") && s.contains("}}") {
+                    let mut context = Context::new();
+                    for (key, val) in &vals {
+                        context.insert(key, val);
+                    }
+
+                    let rendered_default = render_one_off_template(s, &context, None);
+                    match rendered_default {
+                        Err(e) => return Err(e),
+                        Ok(v) => v,
+                    }
+                } else {
+                    s.clone()
+                };
+
+                let res = if no_input {
+                    default_value
+                } else {
+                    ask_string(&var.prompt, &default_value, &var.validation)?
+                };
+
+                vals.insert(var.name.clone(), Value::String(res));
+                continue;
+            }
+            Value::Integer(i) => {
+                let res = if no_input { *i } else { ask_integer(&var.prompt, *i)? };
+                vals.insert(var.name.clone(), Value::Integer(res));
+                continue;
+            }
+            _ => return Err(new_error(ErrorKind::InvalidTemplate)),
+        }
+    }
+
+    Ok(vals)
+}
+
 fn bail(e: &dyn Error) -> ! {
     terminal::error(&format!("Error: {}", e));
     let mut cause = e.source();
     while let Some(e) = cause {
-        terminal::error(&format!("Reason: {}", e));
+        terminal::error(&format!("\nReason: {}", e));
         cause = e.source();
     }
     ::std::process::exit(1)
 }
 
+macro_rules! bail_if_err {
+    ($expr:expr) => {{
+        match $expr {
+            Ok(v) => v,
+            Err(e) => bail(&e),
+        }
+    }};
+}
+
+fn execute_hook(hook: &HookFile) -> Result<()> {
+    todo!("write me")
+}
+
 fn main() {
     let cli = Cli::parse();
 
-    if let Some(Command::Validate { path }) = cli.command {
-        let errs = match validate_file(path) {
-            Ok(e) => e,
-            Err(e) => bail(&e),
-        };
+    match cli.command {
+        Some(Command::Validate { path }) => {
+            let errs = bail_if_err!(validate_file(path));
 
-        if !errs.is_empty() {
-            terminal::error("The template.toml is invalid:\n");
-            for err in errs {
-                terminal::error(&format!("- {}\n", err));
+            if !errs.is_empty() {
+                terminal::error("The template.toml is invalid:\n");
+                for err in errs {
+                    terminal::error(&format!("- {}\n", err));
+                }
+                ::std::process::exit(1);
+            } else {
+                terminal::success("The template.toml file is valid!\n");
             }
-            ::std::process::exit(1);
-        } else {
-            terminal::success("The template.toml file is valid!\n");
         }
-    } else {
-        let template = match Template::from_input(&cli.template.unwrap(), cli.directory.as_deref())
-        {
-            Ok(t) => t,
-            Err(e) => bail(&e),
-        };
+        None => {
+            let template = bail_if_err!(Template::from_input(
+                &cli.template.unwrap(),
+                cli.directory.as_deref()
+            ));
 
-        match template.generate(&cli.output_dir, cli.no_input) {
-            Ok(_) => terminal::success("\nEverything done, ready to go!\n"),
-            Err(e) => bail(&e),
-        };
+            // 1. ask questions
+            let variables = bail_if_err!(ask_questions(&template.definition, cli.no_input));
+
+            // 2. run pre-gen hooks
+            let pre_gen_hooks = bail_if_err!(template.get_pre_gen_hooks());
+            if !pre_gen_hooks.is_empty() {}
+
+            // 3. generate
+            bail_if_err!(template.generate(&cli.output_dir, &variables));
+
+            // 4. run post-gen hooks
+            let post_gen_hooks = bail_if_err!(template.get_post_gen_hooks());
+            if !post_gen_hooks.is_empty() {}
+
+            terminal::success("\nEverything done, ready to go!\n");
+        }
     }
 }
diff --git a/src/definition.rs b/src/definition.rs
index b1e1769..22aa06c 100644
--- a/src/definition.rs
+++ b/src/definition.rs
@@ -1,16 +1,16 @@
 use std::collections::HashMap;
+use std::path::PathBuf;
 
 use serde::Deserialize;
 use tera::Context;
 use toml::Value;
 
 use crate::errors::{new_error, ErrorKind, Result};
-use crate::prompt::{ask_bool, ask_choices, ask_integer, ask_string};
 use crate::utils::render_one_off_template;
 
 /// A condition for a question to be asked
 #[derive(Debug, Clone, PartialEq, Deserialize)]
-pub struct VariableCondition {
+pub struct Condition {
     pub name: String,
     pub value: Value,
 }
@@ -37,11 +37,23 @@ pub struct Variable {
     /// A regex pattern to validate the input
     pub validation: Option<String>,
     /// Only ask this variable if that condition is true
-    pub only_if: Option<VariableCondition>,
+    pub only_if: Option<Condition>,
+}
+
+/// A hook that should be ran
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+pub struct Hook {
+    /// The display name for that hook
+    pub name: String,
+    /// The path to the executable file
+    pub path: PathBuf,
+    /// Only run this hook if that condition is true
+    pub only_if: Option<Condition>,
 }
 
 /// The full template struct we get fom loading a TOML file
 #[derive(Debug, Clone, PartialEq, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct TemplateDefinition {
     /// Name of the template
     pub name: String,
@@ -72,19 +84,21 @@ pub struct TemplateDefinition {
     /// http://cookiecutter.readthedocs.io/en/latest/advanced/copy_without_render.html
     #[serde(default)]
     pub copy_without_render: Vec<String>,
+    /// Hooks that should be ran after collecting all variables but before generating the template
+    #[serde(default)]
+    pub pre_gen_hooks: Vec<Hook>,
+    /// Hooks that should be ran after generating the template
+    #[serde(default)]
+    pub post_gen_hooks: Vec<Hook>,
     /// All the questions for that template
     pub variables: Vec<Variable>,
 }
 
 impl TemplateDefinition {
-    /// Ask all the questions of that template and return the answers.
-    /// If `no_input` is `true`, it will automatically pick the default without
-    /// prompting the user
-    pub fn ask_questions(&self, no_input: bool) -> Result<HashMap<String, Value>> {
-        // Tera context doesn't expose a way to get value from a context
-        // so we store them in another hashmap
+    /// Returns the default values for all the variables that have one while following conditions
+    /// TODO: probably remove that fn? see how to test things
+    pub fn default_values(&self) -> Result<HashMap<String, Value>> {
         let mut vals = HashMap::new();
-
         for var in &self.variables {
             // Skip the question if the value is different from the condition
             if let Some(ref cond) = var.only_if {
@@ -98,51 +112,20 @@ impl TemplateDefinition {
                 }
             }
 
-            if let Some(ref choices) = var.choices {
-                let res = if no_input {
-                    var.default.clone()
-                } else {
-                    ask_choices(&var.prompt, &var.default, choices)?
-                };
-                vals.insert(var.name.clone(), res);
-                continue;
-            }
-
             match &var.default {
                 Value::Boolean(b) => {
-                    let res = if no_input { *b } else { ask_bool(&var.prompt, *b)? };
-                    vals.insert(var.name.clone(), Value::Boolean(res));
-                    continue;
+                    vals.insert(var.name.clone(), Value::Boolean(*b));
                 }
                 Value::String(s) => {
-                    let default_value = if s.contains("{{") && s.contains("}}") {
-                        let mut context = Context::new();
-                        for (key, val) in &vals {
-                            context.insert(key, val);
-                        }
-
-                        let rendered_default = render_one_off_template(s, &context, None);
-                        match rendered_default {
-                            Err(e) => return Err(e),
-                            Ok(v) => v,
-                        }
-                    } else {
-                        s.clone()
-                    };
-
-                    let res = if no_input {
-                        default_value
-                    } else {
-                        ask_string(&var.prompt, &default_value, &var.validation)?
-                    };
-
-                    vals.insert(var.name.clone(), Value::String(res));
-                    continue;
+                    let mut context = Context::new();
+                    for (key, val) in &vals {
+                        context.insert(key, val);
+                    }
+                    let rendered_default = render_one_off_template(s, &context, None)?;
+                    vals.insert(var.name.clone(), Value::String(rendered_default));
                 }
                 Value::Integer(i) => {
-                    let res = if no_input { *i } else { ask_integer(&var.prompt, *i)? };
-                    vals.insert(var.name.clone(), Value::Integer(res));
-                    continue;
+                    vals.insert(var.name.clone(), Value::Integer(*i));
                 }
                 _ => return Err(new_error(ErrorKind::InvalidTemplate)),
             }
@@ -189,7 +172,7 @@ mod tests {
         .unwrap();
 
         assert_eq!(tpl.variables.len(), 3);
-        let res = tpl.ask_questions(true);
+        let res = tpl.default_values();
         assert!(res.is_ok());
     }
 
@@ -208,7 +191,7 @@ mod tests {
 
             [[variables]]
             name = "database"
-            default = "postgres"
+            default = "mysql"
             prompt = "Which database to use?"
             choices = ["postgres", "mysql"]
 
@@ -217,14 +200,14 @@ mod tests {
             prompt = "Which version of Postgres?"
             default = "10.4"
             choices = ["10.4", "9.3"]
-            only_if = { name = "database", value = "mysql" }
+            only_if = { name = "database", value = "postgres" }
 
         "#,
         )
         .unwrap();
 
         assert_eq!(tpl.variables.len(), 3);
-        let res = tpl.ask_questions(true);
+        let res = tpl.default_values();
         assert!(res.is_ok());
         let res = res.unwrap();
         assert!(!res.contains_key("pg_version"));
@@ -266,7 +249,7 @@ mod tests {
         .unwrap();
 
         assert_eq!(tpl.variables.len(), 4);
-        let res = tpl.ask_questions(true);
+        let res = tpl.default_values();
         assert!(res.is_ok());
         let res = res.unwrap();
         assert!(!res.contains_key("pg_version"));
@@ -301,7 +284,7 @@ mod tests {
 
         assert_eq!(tpl.variables.len(), 3);
 
-        let res = tpl.ask_questions(true);
+        let res = tpl.default_values();
 
         assert!(res.is_ok());
         let res = res.unwrap();
diff --git a/src/errors.rs b/src/errors.rs
index 79585df..58c6f05 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -5,7 +5,7 @@ use std::path::{Path, PathBuf};
 use std::result;
 
 /// A crate private constructor for `Error`.
-pub(crate) fn new_error(kind: ErrorKind) -> Error {
+pub fn new_error(kind: ErrorKind) -> Error {
     Error { kind, source: None }
 }
 
diff --git a/src/generation.rs b/src/generation.rs
index fc57e85..99d8d77 100644
--- a/src/generation.rs
+++ b/src/generation.rs
@@ -1,23 +1,50 @@
+use std::collections::HashMap;
 use std::env;
 use std::fs::{self, File};
-use std::io::Read;
+use std::io::{Read, Write};
 use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::str;
 
 use glob::Pattern;
+use tempfile::NamedTempFile;
 use tera::Context;
+use toml::Value;
 use walkdir::WalkDir;
 
-use crate::definition::TemplateDefinition;
+use crate::definition::{Hook, TemplateDefinition};
 use crate::errors::{map_io_err, new_error, ErrorKind, Result};
 use crate::utils::{
     create_directory, get_source, is_binary, read_file, render_one_off_template, write_file, Source,
 };
 
+/// Contains information about a given hook: what's the original path and what's the path
+/// to the templated version
+#[derive(Debug)]
+pub struct HookFile {
+    original_path: PathBuf,
+    file: NamedTempFile,
+}
+
+impl HookFile {
+    /// The hook original path in the template folder
+    pub fn original_path(&self) -> &Path {
+        self.original_path.as_path()
+    }
+
+    /// The rendered hook file, this is what you want to execute.
+    pub fn path(&self) -> &Path {
+        self.file.path()
+    }
+}
+
 /// The current template being generated
 #[derive(Debug, PartialEq)]
 pub struct Template {
+    /// The parsed template definition
+    pub definition: TemplateDefinition,
+    /// The variables set by the user, either interactively or through the library
+    variables: HashMap<String, Value>,
     /// Local path to the template folder
     path: PathBuf,
 }
@@ -29,7 +56,7 @@ impl Template {
     pub fn from_input(input: &str, directory: Option<&str>) -> Result<Template> {
         match get_source(input) {
             Source::Git(remote) => Template::from_git(&remote, directory),
-            Source::Local(path) => Ok(Template::from_local(&path, directory)),
+            Source::Local(path) => Template::from_local(&path, directory),
         }
     }
 
@@ -50,22 +77,15 @@ impl Template {
             .args(["clone", "--recurse-submodules", remote, &format!("{}", tmp.display())])
             .output()
             .map_err(|err| new_error(ErrorKind::Git { err }))?;
-        Ok(Template::from_local(&tmp, directory))
+        Template::from_local(&tmp, directory)
     }
 
-    pub fn from_local(path: &Path, directory: Option<&str>) -> Template {
+    pub fn from_local(path: &Path, directory: Option<&str>) -> Result<Template> {
         let mut buf = path.to_path_buf();
         if let Some(dir) = directory {
             buf.push(dir);
         }
-        Template { path: buf }
-    }
-
-    /// Generate the template at the given output directory
-    pub fn generate(&self, output_dir: &Path, no_input: bool) -> Result<()> {
-        let output_dir = output_dir.canonicalize()?;
-        // Get the variables from the user first
-        let conf_path = self.path.join("template.toml");
+        let conf_path = buf.join("template.toml");
         if !conf_path.exists() {
             return Err(new_error(ErrorKind::MissingTemplateDefinition));
         }
@@ -73,9 +93,67 @@ impl Template {
         let definition: TemplateDefinition = toml::from_str(&read_file(&conf_path)?)
             .map_err(|err| new_error(ErrorKind::Toml { err }))?;
 
-        let variables = definition.ask_questions(no_input)?;
+        Ok(Template { path: buf, definition, variables: HashMap::new() })
+    }
+
+    /// Overwrites the variables for the template
+    pub fn set_variables(&mut self, variables: HashMap<String, Value>) {
+        self.variables = variables;
+    }
+
+    fn get_hooks(&self, hooks: &[Hook]) -> Result<Vec<HookFile>> {
+        let mut context = Context::new();
+        for (key, val) in &self.variables {
+            context.insert(key, val);
+        }
+
+        let mut hooks_files = Vec::new();
+
+        for hook in hooks {
+            // First we check whether we need to run it or not
+            if let Some(cond) = &hook.only_if {
+                if let Some(val) = self.variables.get(&cond.name) {
+                    if *val != cond.value {
+                        continue;
+                    }
+                } else {
+                    // Not having it means we didn't even ask the question
+                    continue;
+                }
+            }
+
+            // Then we will read the content of the file and run it through Tera
+            let content = read_file(&hook.path)?;
+            let rendered = render_one_off_template(&content, &context, Some(hook.path.clone()))?;
+
+            // Then we save it in a temporary file
+            let mut file = NamedTempFile::new()?;
+            write!(file, "{}", rendered)?;
+            hooks_files.push(HookFile { file, original_path: hook.path.clone() });
+        }
+
+        Ok(hooks_files)
+    }
+
+    /// Returns the paths of the hooks that need to be ran in the pre-gen step.
+    /// The path will point to a temporary file and not the path of the template as it will
+    /// be templated.
+    pub fn get_pre_gen_hooks(&self) -> Result<Vec<HookFile>> {
+        self.get_hooks(&self.definition.pre_gen_hooks)
+    }
+
+    /// Returns the paths of the hooks that need to be ran in the post-gen step.
+    /// The path will point to a temporary file and not the path of the template as it will
+    /// be templated.
+    pub fn get_post_gen_hooks(&self) -> Result<Vec<HookFile>> {
+        self.get_hooks(&self.definition.post_gen_hooks)
+    }
+
+    /// Generate the template at the given output directory
+    pub fn generate(&self, output_dir: &Path, variables: &HashMap<String, Value>) -> Result<()> {
+        let output_dir = output_dir.canonicalize()?;
         let mut context = Context::new();
-        for (key, val) in &variables {
+        for (key, val) in variables {
             context.insert(key, val);
         }
 
@@ -84,8 +162,8 @@ impl Template {
         }
 
         // Create the glob patterns of files to copy without rendering first, only once
-        let mut patterns = Vec::with_capacity(definition.copy_without_render.len());
-        for s in &definition.copy_without_render {
+        let mut patterns = Vec::with_capacity(self.definition.copy_without_render.len());
+        for s in &self.definition.copy_without_render {
             let rendered = render_one_off_template(s, &context, None)?;
             match Pattern::new(&rendered) {
                 Ok(p) => patterns.push(p),
@@ -99,7 +177,7 @@ impl Template {
             };
         }
 
-        let start_path = if let Some(ref directory) = definition.directory {
+        let start_path = if let Some(ref directory) = self.definition.directory {
             self.path.join(directory)
         } else {
             self.path.clone()
@@ -122,7 +200,7 @@ impl Template {
 
         'outer: for entry in walker {
             // Skip root folder and the template.toml
-            if entry.path() == self.path || entry.path() == conf_path {
+            if entry.path() == self.path || entry.path() == self.path.join("template.toml") {
                 continue;
             }
 
@@ -131,7 +209,7 @@ impl Template {
                 continue;
             }
             let path_str = format!("{}", path.display());
-            for ignored in &definition.ignore {
+            for ignored in &self.definition.ignore {
                 if ignored == &path_str || path_str.starts_with(ignored) {
                     continue 'outer;
                 }
@@ -169,7 +247,7 @@ impl Template {
             write_file(&real_path, &contents)?;
         }
 
-        for cleanup in &definition.cleanup {
+        for cleanup in &self.definition.cleanup {
             if let Some(val) = variables.get(&cleanup.name) {
                 if *val == cleanup.value {
                     for p in &cleanup.paths {
@@ -203,8 +281,9 @@ mod tests {
     fn can_generate_from_local_path() {
         let dir = tempdir().unwrap();
         let tpl = Template::from_input("examples/complex", None).unwrap();
-        let res = tpl.generate(&dir.path().to_path_buf(), true);
-        println!("{res:?}");
+        let res =
+            tpl.generate(&dir.path().to_path_buf(), &tpl.definition.default_values().unwrap());
+
         assert!(res.is_ok());
         assert!(!dir.path().join("some-project").join("template.toml").exists());
         assert!(dir.path().join("some-project").join("logo.png").exists());
@@ -214,7 +293,8 @@ mod tests {
     fn can_generate_from_local_path_with_directory() {
         let dir = tempdir().unwrap();
         let tpl = Template::from_input("examples/with-directory", None).unwrap();
-        let res = tpl.generate(&dir.path().to_path_buf(), true);
+        let res =
+            tpl.generate(&dir.path().to_path_buf(), &tpl.definition.default_values().unwrap());
         assert!(res.is_ok());
         assert!(dir.path().join("template_root").join("Howdy.py").exists());
     }
@@ -223,7 +303,8 @@ mod tests {
     fn can_generate_from_local_path_with_directory_param() {
         let dir = tempdir().unwrap();
         let tpl = Template::from_input("./", Some("examples/complex")).unwrap();
-        let res = tpl.generate(&dir.path().to_path_buf(), true);
+        let res =
+            tpl.generate(&dir.path().to_path_buf(), &tpl.definition.default_values().unwrap());
         assert!(res.is_ok());
         assert!(!dir.path().join("some-project").join("template.toml").exists());
         assert!(dir.path().join("some-project").join("logo.png").exists());
@@ -233,8 +314,9 @@ mod tests {
     fn can_generate_from_remote_repo() {
         let dir = tempdir().unwrap();
         let tpl = Template::from_input("https://github.com/Keats/rust-cli-template", None).unwrap();
-        let res = tpl.generate(&dir.path().to_path_buf(), true);
-        println!("{:?}", res);
+        let res =
+            tpl.generate(&dir.path().to_path_buf(), &tpl.definition.default_values().unwrap());
+
         assert!(res.is_ok());
         assert!(!dir.path().join("My-CLI").join("template.toml").exists());
         assert!(dir.path().join("My-CLI").join(".travis.yml").exists());
@@ -246,8 +328,9 @@ mod tests {
         let tpl =
             Template::from_input("https://github.com/Keats/kickstart", Some("examples/complex"))
                 .unwrap();
-        let res = tpl.generate(&dir.path().to_path_buf(), true);
-        println!("{:?}", res);
+        let res =
+            tpl.generate(&dir.path().to_path_buf(), &tpl.definition.default_values().unwrap());
+
         assert!(res.is_ok());
         assert!(!dir.path().join("some-project").join("template.toml").exists());
         assert!(dir.path().join("some-project").join("logo.png").exists());
@@ -257,7 +340,8 @@ mod tests {
     fn can_generate_handling_slugify() {
         let dir = tempdir().unwrap();
         let tpl = Template::from_input("examples/slugify", None).unwrap();
-        let res = tpl.generate(&dir.path().to_path_buf(), true);
+        let res =
+            tpl.generate(&dir.path().to_path_buf(), &tpl.definition.default_values().unwrap());
         assert!(res.is_ok());
         assert!(!dir.path().join("template.toml").exists());
         assert!(dir.path().join("hello.md").exists());
diff --git a/src/lib.rs b/src/lib.rs
index c46106f..11180bd 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -9,8 +9,12 @@
 mod definition;
 pub mod errors;
 mod filters;
-pub mod generation;
-mod prompt;
+mod generation;
+pub mod prompt;
 pub mod terminal;
-mod utils;
-pub mod validate;
+pub mod utils;
+mod validate;
+
+pub use definition::TemplateDefinition;
+pub use generation::{HookFile, Template};
+pub use validate::validate_file;
diff --git a/src/validate.rs b/src/validate.rs
index a273005..b1a4def 100644
--- a/src/validate.rs
+++ b/src/validate.rs
@@ -14,6 +14,9 @@ pub fn validate_definition(def: &TemplateDefinition) -> Vec<String> {
     let mut errs = vec![];
     let mut types = HashMap::new();
 
+    // TODO: check the hooks files exists and are executable
+    // TODO: validate glob patterns
+
     for var in &def.variables {
         let type_str = var.default.type_str();
         types.insert(var.name.to_string(), type_str);