# Tutorial: Create an AutoMan Project

Once you have Java, Scala, and `sbt` installed (if you don't go back to [Installing Prerequisites](/getting-started/installation-tutorial.md)), you can create an AutoMan project.  Note that these instructions assume that you are familiar with the command line on a UNIX machine.  You can run AutoMan in other operating systems, like Windows, but you will need to adapt the instructions below.

## Create a project folder

We're going to start by creating a new directory for our project.  This will create a new directory in our current location.

```bash
$ mkdir my-first-automan-project
```

Now go ahead and `cd` into that directory.

```bash
$ cd my-first-automan-project
```

In any `sbt` project, there are two primary components:

* `build.sbt`: Is a build specification, where you will configure your library dependencies, among other things.
* `src`: Is a directory where you will store your application code.

## build.sbt

Let's start by creating a `build.sbt` file.  I am going to do this with `emacs build.sbt` but you can use any text editor with which you are comfortable.  Paste the following into your `build.sbt` file:

```scala
scalaVersion := "2.12.12"
name := "my-first-automan-app"
version := "1.0"
libraryDependencies += "org.automanlang" %% "automan" % "1.4.2"
```

Most of this should be self-explanatory, but I will explain anyway.  Note that you must use the `:=` assignment operator and not `=` in `build.sbt` files.

* `scalaVersion`: The version of Scala you want to use.  I have specified the latest version of Scala 2.12 at the time of this writing. If you don't have this precise version of Scala on your machine, don't worry,`sbt` will install it for you.  Note that AutoMan does not currently support Scala 2.13.
* `name`: The name of your application.
* `version`: The version of your application.  This won't be all that important for this example, but if you ever decide to publish your app, this number will be used as a part of your app's metadata.
* `libraryDependencies`: This is where we specify that our app depends on one or more third-party libraries.  I have pre-filled this entry with the dependency information for the latest version of AutoMan.  `sbt` will automatically download and install whatever dependencies you specify.  Observe that we use `+=` for `libraryDependencies`; this is because `libraryDependencies` is a list.  `+=` adds a dependency to that list.

{% hint style="info" %}
You can find more libraries at [MVNrepository](https://mvnrepository.com/).  For example, [here is the MVNrepository page for AutoMan](https://mvnrepository.com/artifact/org.automanlang/automan_2.12/1.4.2).  Note the "SBT" tab which includes the line we pasted into our `build.sbt` file above.  You can include *any* third-party library you find in MVNrepository, with some small caveats, most notably that some libraries are tied to specific versions of Scala.  Just add another `libraryDependencies` line using `+=`.
{% endhint %}

## src/main/scala and source files

Let's now create our `src` directory.  `sbt` saves you configuration work by being rather picky about where you store your source code.  Let's create that location:

```
$ mkdir -p src/main/scala
```

 And let's create a new Scala file in that folder (again, use your favorite text editor):

```
$ emacs src/main/scala/MyFirstAutoManApp.scala
```

Once you have a new, blank `MyFirstAutoManApp.scala` file loaded up in your editor, we can start creating our app.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.automanlang.org/getting-started/creating-a-new-project.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.